public void SetMessagePublisherConfiguration(IServiceConfiguration messagePublisherConfiguration)
{
if (HostState == HostState.AwaitingConfiguration)
{
MessagePublisherConfiguration = messagePublisherConfiguration;
}
}
private static string GetServiceValueString(this IServiceConfiguration configuration, string valueKey)
{
#region Contracts
if (configuration == null)
{
throw new ArgumentException(nameof(configuration));
}
if (string.IsNullOrEmpty(valueKey) == true)
{
throw new ArgumentException(nameof(valueKey));
}
#endregion
// ServiceValueString
var serviceValueString = configuration.ServiceSection?.GetValue <string>(valueKey);
if (string.IsNullOrEmpty(serviceValueString) == true)
{
return(null);
}
// Return
return(serviceValueString);
}
public ServiceConfigurationServiceConfigurationKey(
IServiceConfiguration serviceConfiguration,
ServiceConfigurationKey serviceConfigurationKey)
{
ServiceConfiguration = serviceConfiguration;
ServiceConfigurationKey = serviceConfigurationKey;
}
public IServiceContext AsServiceApplication(IServiceConfiguration serviceConfiguration, ICodingStyle codingStyle)
{
var coreContext = new DefaultCoreContext(codingStyle, cache);
var service = InterceptIfConfigured(new ObjectService(coreContext, cache));
return(new DefaultServiceContext(coreContext, serviceConfiguration, service));
}
public static Object GetInstance(
this IServiceConfiguration configuration,
ServiceProvider provider,
Type[] generics,
Action <Object, ServiceProvider, IServiceConfiguration> setup,
Int32 setupOrder)
=> provider.GetServiceManager(configuration, generics).GetInstance(setup, setupOrder);
/// <summary>
/// Creates an OrganizationServiceProxy using the specified settings. This should always be wrapped in a using statement so the dispose method is called.
/// </summary>
/// <param name="crmOrganizationUrl">The CRM organization URL.</param>
/// <param name="crmSdkServerUrl">The CRM Sdk server URL.</param>
/// <param name="crmOrganization">The CRM organization.</param>
/// <param name="impersonationUserId">The impersonation user id.</param>
/// <param name="enableProxyTypes">if set to <c>true</c> [enable proxy types].</param>
/// <param name="ifdUserName">IFD's User Name </param>
/// <param name="ifdPassword">IFD User's Password</param>
/// <param name="isIfdDeployment">Indicates whether this is an IFD Deployment.</param>
/// <returns></returns>
public static OrganizationServiceProxy CreateOrgProxy(string crmOrganizationUrl, string crmSdkServerUrl, string crmOrganization, Guid impersonationUserId = new Guid(), bool enableProxyTypes = true, bool isIfdDeployment = false, string ifdUserName = "", string ifdPassword = "")
{
crmOrganization = GetCrmOrganizationName(crmSdkServerUrl, crmOrganization);
Uri orgUri = GetOrganizationServiceUri(crmOrganizationUrl, crmOrganization, isIfdDeployment);
IServiceConfiguration <IOrganizationService> orgConfigInfo = ServiceConfigurationFactory.CreateConfiguration <IOrganizationService>(orgUri);
var creds = new ClientCredentials();
if (isIfdDeployment)
{
creds.UserName.UserName = ifdUserName;
creds.UserName.Password = ifdPassword;
}
OrganizationServiceProxy orgService = new OrganizationServiceProxy(orgConfigInfo, creds);
if (enableProxyTypes)
{
;
orgService.EnableProxyTypes(GetEarlyBoundProxyAssembly());
}
if (impersonationUserId != Guid.Empty)
{
orgService.CallerId = impersonationUserId;
}
return(orgService);
}
public HttpDiagnosticsService(IServiceConfiguration configuration)
{
this.configuration = configuration;
collector = new TimeSeriesCollector();
carbonWriter = CarbonWriterFactory.Instance();
graphDataHandler = new GraphDataHandler(collector);
}
public void SetComponentConfiguration(IServiceConfiguration componentConfiguration)
{
if (HostState == HostState.AwaitingConfiguration)
{
ComponentConfiguration = componentConfiguration;
}
}
public static void BuildInstance(
this IServiceConfiguration configuration,
ServiceProvider provider,
Type[] generics,
Action <Object, ServiceProvider, IServiceConfiguration> setup,
Int32 setupOrder,
out Object instance)
{
instance = configuration.TypeFactory.BuildInstance(provider.Root, generics);
Boolean ranSetup = false;
foreach (SetupAction action in configuration.SetupActions)
{
if (!ranSetup && action.Order >= setupOrder)
{
setup(instance, provider, configuration);
ranSetup = true;
}
action.Invoke(instance, provider, configuration);
}
if (!ranSetup)
{
setup(instance, provider, configuration);
}
}
public IOrganizationService GetOrganisationService(OrganizationDetail org, string domain, string userName, string password)
{
if (org != null)
{
Uri orgServiceUri = null;
orgServiceUri = new Uri(org.Endpoints[EndpointType.OrganizationService]);
//if (!string.IsNullOrEmpty(OrganisationServiceHostName))
//{
// UriBuilder builder = new UriBuilder(orgServiceUri);
// builder.Host = OrganisationServiceHostName;
// orgServiceUri = builder.Uri;
//}
IServiceConfiguration <IOrganizationService> orgConfigInfo = ServiceConfigurationFactory.CreateConfiguration <IOrganizationService>(orgServiceUri);
var creds = _credentialsProvider.GetCredentials(orgConfigInfo.AuthenticationType, domain, userName, password);
var orgService = new OrganizationServiceProxy(orgConfigInfo, creds);
orgService.Timeout = new TimeSpan(0, 5, 0);
var req = new WhoAmIRequest();
var response = (WhoAmIResponse)orgService.Execute(req);
Debug.WriteLine(string.Format(" Connected to {0} as Crm user id: {1}", orgConfigInfo.CurrentServiceEndpoint.Address.Uri.ToString(), response.UserId));
return(orgService);
}
return(null);
}
/// <summary>
/// Get value based on key
/// </summary>
/// <typeparam name="T">type</typeparam>
/// <param name="self">Service configuration</param>
/// <param name="key">key</param>
/// <param name="throwNotFound">true, throw if key is not found</param>
/// <returns>value, null if not found</returns>
public static T Get <T>(this IServiceConfiguration self, string key, bool throwNotFound = false) where T : class
{
Verify.IsNotNull(nameof(self), self);
Verify.IsNotEmpty(nameof(key), key);
return(self.Properties.Get <T>(key, throwNotFound: throwNotFound));
}
public bool IsInitQueue(string serviceName)
{
try
{
IBusQueue queue = GetQueue(serviceName);
if (queue == null)
{
IServiceConfiguration config = _config.Services.FirstOrDefault(x => x.ServiceName == serviceName);
if (config != null)
{
queue = new BusQueue(_connection, config, _logger);
_queueList.Add(queue);
}
if (queue == null)
{
return(false);
}
}
return(queue.TryInit());
}
catch (Exception e)
{
_logger?.LogError(e, $"{_config.LocalIP} : {_config.ApplicationName}.{typeof(BusManager).FullName} : {e.Message}");
return(false);
}
}
public override void Setup()
{
ServiceConfiguration = new ServiceConfiguration {
new EmployerAccountSiteManifest()
};
MockManifestRepository = new Mock <IManifestRepository>();
MockPermissionsChecker = new Mock <ICheckPermissions>();
MockPermissionsGranter = new Mock <IGrantPermissions>();
Unit = new Portal.Web.Controllers.ResourceController(
MockManifestRepository.Object,
MockPermissionsChecker.Object,
MockPermissionsGranter.Object,
ServiceConfiguration);
MockContextBase = new Mock <HttpContextBase>();
MockContextBase.Setup(x => x.Request).Returns(new Mock <HttpRequestBase>().Object);
MockContextBase.Setup(x => x.Response).Returns(new Mock <HttpResponseBase>().Object);
MockContextBase.Setup(x => x.User).Returns(new Mock <IPrincipal>().Object);
UnitControllerContext = new ControllerContext(MockContextBase.Object, new RouteData(), Unit);
Unit.ControllerContext = UnitControllerContext;
}
internal IServiceManager GetServiceManager(
IServiceConfiguration configuration,
Type[] generics)
{
var key = configuration.TypeFactory.MutateKey(configuration.Key, generics);
var compKey = new ServiceConfigurationServiceConfigurationKey(configuration, key);
IServiceManager manager;
if (!_activeServices.TryGetValue(compKey, out manager))
{
manager = configuration.BuildServiceManager(this, generics);
_activeServices.Add(compKey, manager);
// Cache the primary service key if neccessary
if (!_primaryActiveService.ContainsKey(key))
{
_primaryActiveService.Add(key, manager);
}
// Attempt to cache all configuration cache keys. These must succeed. If an overlap is detected an exception will be thrown.
foreach (ServiceConfigurationKey cacheKey in configuration.TypeFactory.MutateKeys(configuration.DefaultCacheKeys, generics))
{
_primaryActiveService.Add(cacheKey, manager);
}
}
return(manager);
}
public void SetUp()
{
_host = new Host <TradeServiceStartup>();
_app = _host.Build();
_app.Start();
_configuration = AppCore.Instance.Get <IServiceConfiguration>();
var jsonSettings = new AppJsonSerializer();
var jsonSerializer = JsonSerializer.Create(jsonSettings);
AppCore.Instance.ObjectProvider.Configure(conf => conf.For <JsonSerializerSettings>().Use(jsonSettings));
AppCore.Instance.ObjectProvider.Configure(conf => conf.For <JsonSerializer>().Use(jsonSerializer));
_traderToken = ApiServiceBuilder <IUserService> .Build("http://localhost:8080")
.Create()
.Login(new Credentials()
{
Username = "******",
Password = "******"
}).Result;
_tradeClient = ApiServiceBuilder <ITradeService> .Build("http://localhost:8080")
.AddAuthorizationHeader(() => _traderToken.Digest)
.Create();
_priceClient = AppCore.Instance.GetService <IPriceService>();
Task.Delay(1000);
var publisher = AppCore.Instance.Get <IPublisher>();
publisher.Stop().Wait();
}
public HttpDiagnosticsService(IServiceConfiguration configuration)
{
this.configuration = configuration;
collector = new TimeSeriesCollector();
carbonWriter = CarbonWriterFactory.Instance();
graphDataHandler = new GraphDataHandler(collector);
}
/// <summary>
/// Converts to HATEOAS response.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="path">The path.</param>
/// <param name="isPostPut">if set to <c>true</c> [is post put].</param>
/// <returns></returns>
private object ConvertToHateoas(object source, IServiceConfiguration configuration, MessagePath path, bool isPostPut = false)
{
IList <HateoasLink> links = path.Links;
JsonSerializer serializer = IoC.Get <JsonSerializer>();
if ((path.HasKeyParameter) || (path.IsByParent) || isPostPut)
{
JObject jobject = JObject.FromObject(source, serializer);
JArray jarray = JArray.FromObject(links, serializer);
if (configuration.IsCamelCase)
{
jobject.Add("links", jarray);
}
else
{
jobject.Add("Links", jarray);
}
return(jobject);
}
else
{
HateoasReponse response = new HateoasReponse();
response.Items = source;
response.Links = links;
return(JObject.FromObject(response, serializer));
}
}
public Message Put(Message message)
{
MessageInformation information = new MessageInformation(message);
try
{
string sessionToken = this.GetSessionToken(information);
MessagePath path = new MessagePath(information);
if (path.HasKeyParameter)
{
throw new ArgumentException("POST operation cannot have a key parameter in the path.");
}
ISecurityManager securityManager = IoC.Get <ISecurityManager>();
dynamic bo = securityManager.DynamicGetBO(path.DtoType, sessionToken);
dynamic dto = information.GetBody(path.DtoType);
object response = bo.Update(dto);
IServiceConfiguration configuration = IoC.Get <IServiceConfiguration>();
JsonSerializerSettings settings = IoC.Get <JsonSerializerSettings>();
if (configuration.IsHateoas)
{
response = this.ConvertToHateoas(response, configuration, path);
}
return(response.ToJsonMessage(settings, configuration.Indented));
}
catch (Exception ex)
{
return(ex.Message.ToJsonMessage());
}
}
public BusQueue(IBusConnection connection, IServiceConfiguration config, ILogger logger = null)
{
_connection = connection;
_config = config;
_logger = logger;
TryInit();
}
public StockChangeHandler(IServiceConfiguration configuration, IAzureTopicSubscriber topicSubscriber, IStockQuantityCommand command, IStockQuantityQuery stockQuantityQuery)
{
_configuration = configuration;
_topicSubscriber = topicSubscriber;
_command = command;
_stockQuantityQuery = stockQuantityQuery;
}
public NewsHeadlineFetcher(IHttpClientFactory httpClient, IServiceConfiguration configuration)
{
// https://www.telerik.com/blogs/.net-core-background-services
_httpClient = httpClient.CreateClient();
_newsServiceUrl = configuration.NewsServiceApiEndpointUri;
_newsServiceUserUrl = configuration.NewsServiceUserUri;
}
protected virtual IServiceConfiguration <IDiscoveryService> GetServiceConfiguration(CrmConnection connection)
{
var mode = connection.ServiceConfigurationInstanceMode;
if (mode == ServiceConfigurationInstanceMode.Static)
{
return(_config ?? (_config = CreateServiceConfiguration(connection)));
}
if (mode == ServiceConfigurationInstanceMode.PerName)
{
var key = connection.GetConnectionId();
if (!_configLookup.ContainsKey(key))
{
_configLookup[key] = CreateServiceConfiguration(connection);
}
return(_configLookup[key]);
}
if (mode == ServiceConfigurationInstanceMode.PerRequest && HttpSingleton <IServiceConfiguration <IDiscoveryService> > .Enabled)
{
var key = connection.GetConnectionId();
return(HttpSingleton <IServiceConfiguration <IDiscoveryService> > .GetInstance(key, () => CreateServiceConfiguration(connection)));
}
var config = CreateServiceConfiguration(connection);
return(config);
}
public AddPlayerToGameRequestDialog(IEnumerable <ICommunicator> communicators, Guid userId,
AddPlayerToGameRequest dialogData,
ILogger logger, IMediator mediator, IThreadContextSessionProvider threadContextSessionProvider,
IGameRepository gameRepository, IServiceConfiguration serviceConfiguration) : base(logger, communicators,
userId, dialogData)
{
_mediator = mediator;
_threadContextSessionProvider = threadContextSessionProvider;
_gameRepository = gameRepository;
_serviceConfiguration = serviceConfiguration;
_hasDesicion = false;
using (threadContextSessionProvider.CreateSessionScope())
{
var games = gameRepository.ListBySpecification(new UndeletedEntities <Game>()).ToList();
games = games.Where(x =>
x.AcceptedPlayers.Count + x.RequestedPlayers.Count <serviceConfiguration.PlayersPerTeam * 2 &&
x.IsActive &&
x.DateTime>
DateTime.Now
.Add(
serviceConfiguration
.GameDeadline,
serviceConfiguration
.StartDayTime,
serviceConfiguration
.EndDayTime))
.OrderBy(x => x.DateTime)
.Take(20).ToList();
if (!games.Any())
{
Add($"Нет игр для добавления игроков");
}
else
{
Add($"Введи номер игры, в которую хочешь добавить игроков:");
var gamesMessage = string.Join("\n",
games.Select((x, index) =>
$"{index + 1}. Дата: {x.DateTime.ToString(DateTimeHelper.DateFormat)}"));
Add(gamesMessage);
Add((message, data) =>
{
if (!int.TryParse(message, out var number) || (number < 1 && number > games.Count()))
{
throw new InvalidInputException($"Введи номер игры от 1 до {games.Count()}");
}
data.GameId = games[number - 1].Id;
var game = games[number - 1];
AddPlayerProcessingMessages(game.Id);
return(data);
});
}
}
}
public void Install(IServiceConfiguration configuration)
{
Guard.AgainstNull(configuration, nameof(configuration));
GuardAdministrator();
if (!string.IsNullOrEmpty(configuration.ServicePath))
{
new ServiceInvoker(configuration).Execute(ServiceCommand.Install);
return;
}
CallContext.LogicalSetData(ServiceConfigurationKey, configuration);
var instancedServiceName = configuration.GetInstancedServiceName();
var log = ServiceHostEventLog.GetEventLog(instancedServiceName);
ConsoleExtensions.WriteLine(ConsoleColor.Green, $"Installing service '{instancedServiceName}'.");
var entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly == null)
{
throw new InvalidOperationException("An entry assembly is required in order to install a service.");
}
var entryAssemblyLocation = entryAssembly.Location;
if (string.IsNullOrEmpty(entryAssemblyLocation))
{
throw new InvalidOperationException("The entry assembly has no location.");
}
if (!Path.GetExtension(entryAssemblyLocation).Equals(".exe", StringComparison.InvariantCultureIgnoreCase))
{
throw new InvalidOperationException(
"The entry assembly must be an 'exe' in order to install as a service.");
}
var assemblyInstaller = new AssemblyInstaller(typeof(ServiceHost).Assembly, null);
using (var installer = assemblyInstaller)
{
IDictionary state = new Hashtable();
installer.UseNewContext = true;
try
{
installer.Install(state);
installer.Commit(state);
var serviceKey = GetServiceKey(instancedServiceName);
serviceKey.SetValue("Description", configuration.Description);
serviceKey.SetValue("ImagePath",
$"{entryAssemblyLocation} /serviceName=\"{configuration.ServiceName}\"{(string.IsNullOrEmpty(configuration.Instance) ? string.Empty : $" /instance=\"{configuration.Instance}\"")}");
}
internal ScopedServiceManager(
IServiceConfiguration configuration,
ServiceProvider provider,
Type[] generics) : base(configuration, provider, generics)
{
_getInstance = this.BuildInstance;
_getInstanceWithSetup = this.BuildInstance;
}
public static IApplicationBuilder UseSwagger(this IApplicationBuilder app, IServiceConfiguration serviceConfiguration)
{
app.UseSwagger();
return(app.UseSwaggerUI(options =>
{
options.SwaggerEndpoint($"/swagger/v{serviceConfiguration.Version}/swagger.json", $"API [{serviceConfiguration.Name}] v.{serviceConfiguration.Version}");
}));
}
public DefaultServiceStarter(IServiceHost serviceHost, IServiceConfiguration serviceConfiguration, TClient client)
{
Client = client;
ServiceHost = serviceHost;
Environment = new Dictionary <string, object> {
{ Service.EnvironmentKeys.StartParameters, serviceConfiguration.StartParameters }
};
}
public ConsoleService(IServiceHostStart service, IServiceConfiguration configuration)
{
Guard.AgainstNull(service, nameof(service));
Guard.AgainstNull(configuration, nameof(configuration));
_configuration = configuration;
_service = service;
}
public override IRestResponse <TResult> GetResponse <TResult>(IServiceConfiguration serviceConfiguration, IRestClient client, IRestRequest restRequest)
{
var response = base.GetResponse <TResult>(serviceConfiguration, client, restRequest);
Log.Debug("Sitecore.RestSharp: Response data:\n" + JsonConvert.SerializeObject(response, Formatting.Indented), this);
return(response);
}
public Message Get(Message message)
{
MessageInformation information = new MessageInformation(message);
try
{
string sessionToken = this.GetSessionToken(information);
MessagePath path = new MessagePath(information);
ISecurityManager securityManager = IoC.Get <ISecurityManager>();
object response;
if (path.IsByParent)
{
MessagePath parentPath = new MessagePath(information, true);
if (!parentPath.HasKeyParameter)
{
throw new ArgumentException("A link to a parent must have parameter key");
}
dynamic bo = securityManager.DynamicGetBO(parentPath.DtoType, sessionToken);
object parent = bo.GetOne(string.Empty, parentPath.QueryInfo);
IObjectProxy proxy = ObjectProxyFactory.Get(parent);
object value = proxy.GetValue(parent, path.ParentKeyParameter);
QueryInfo query = new QueryInfo();
query.Equal(path.KeyParameterName, value.ToString());
bo = securityManager.DynamicGetBO(path.DtoType, sessionToken);
response = bo.GetOne(string.Empty, query);
}
else
{
dynamic bo = securityManager.DynamicGetBO(path.DtoType, sessionToken);
if (path.HasKeyParameter)
{
response = bo.GetOne(string.Empty, path.QueryInfo);
}
else
{
response = bo.GetAll(path.QueryInfo);
}
}
IServiceConfiguration configuration = IoC.Get <IServiceConfiguration>();
JsonSerializerSettings settings = IoC.Get <JsonSerializerSettings>();
if (configuration.IsHateoas)
{
response = this.ConvertToHateoas(response, configuration, path);
}
return(response.ToJsonMessage(settings, configuration.Indented));
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
{
return(ex.InnerException.Message.ToJsonMessage());
}
else
{
return(ex.Message.ToJsonMessage());
}
}
}
internal TransientServiceManager(
IServiceConfiguration configuration,
ServiceProvider provider,
Type[] generics)
{
this.configuration = configuration;
this.provider = provider;
this.generics = generics;
}
/// <summary>
/// Helper method to get a calendar factory, consider splitting this out into yet another factory class.
/// </summary>
/// <param name="calendarConfiguration"></param>
/// <param name="serviceConfiguration"></param>
/// <returns></returns>
private ICalendarFactory GetCalendarFactory(ICalendarConfiguration calendarConfiguration, IServiceConfiguration serviceConfiguration)
{
switch (calendarConfiguration.CalendarType)
{
case CalendarType.Google:
return GetGoogleCalendarFactory(calendarConfiguration, serviceConfiguration);
case CalendarType.Exchange:
return GetExchangeCalendarFactory(calendarConfiguration);
default:
throw new InvalidDataException("Unknown calendar type");
}
}
public void Start(IServiceConfiguration configuration)
{
BioData.BioSkyNetRepository _database = _locator.GetProcessor<BioData.BioSkyNetRepository>();
_server = new Server
{
Services = { BiometricDatabaseSevice.BindService(new BiometricDatabaseSeviceImpl(_database)) },
Ports = { new ServerPort(configuration.IpAddress, configuration.Port, ServerCredentials.Insecure) }
};
_server.Start();
Console.WriteLine("BiometricDatabaseSevice server listening on port " + configuration.Port);
Console.WriteLine("Press any key to stop the server...");
}
/// <summary>
/// Configures the API from a root node.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="configuration">The configuration.</param>
private static void ConfigureApi(XmlNode node, IServiceConfiguration configuration)
{
NodeAttributes attributes = new NodeAttributes(node);
Type dtoType = GetDtoType(attributes.AsString("dtoType"), attributes.AsString("dtoName"), attributes.AsString("path"), attributes.AsString("entityName"), attributes.AsString("entityType"));
if (dtoType != null)
{
string parameterName = attributes.AsString("parameterName");
if (string.IsNullOrEmpty(parameterName))
{
parameterName = GetParameterName(attributes.AsString("path"), dtoType);
}
ApiNode childnode = configuration.AddNode(attributes.AsString("path"), dtoType, parameterName, attributes.AsString("byparent"));
foreach (XmlNode subnode in node.SelectNodes("api"))
{
ConfigureApi(subnode, childnode);
}
}
}
public HttpHostConfiguration AddServiceConfiguration(IServiceConfiguration configureService)
{
this.serviceConfiguration.Add(configureService);
return this;
}
/// <summary>
/// Converts to HATEOAS response.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="path">The path.</param>
/// <param name="isPostPut">if set to <c>true</c> [is post put].</param>
/// <returns></returns>
private object ConvertToHateoas(object source, IServiceConfiguration configuration, MessagePath path, bool isPostPut = false)
{
IList<HateoasLink> links = path.Links;
JsonSerializer serializer = IoC.Get<JsonSerializer>();
if ((path.HasKeyParameter) || (path.IsByParent) || isPostPut)
{
JObject jobject = JObject.FromObject(source, serializer);
JArray jarray = JArray.FromObject(links, serializer);
if (configuration.IsCamelCase)
{
jobject.Add("links", jarray);
}
else
{
jobject.Add("Links", jarray);
}
return jobject;
}
else
{
HateoasReponse response = new HateoasReponse();
response.Items = source;
response.Links = links;
return JObject.FromObject(response, serializer);
}
}
public SMDRReaderService(IServiceConfiguration config)
{
_config = config;
_server = new ReactiveListener(_config.Port);
SetupSubscriptions(_server);
}
ClientCredentials CreateDeviceCredentials(IServiceConfiguration<IOrganizationService> orgServiceConfig)
{
if (orgServiceConfig.AuthenticationType != AuthenticationProviderType.LiveId)
{
return null;
}
if (!string.IsNullOrEmpty(Parameters.DeviceID) && !string.IsNullOrEmpty(Parameters.DevicePassword))
{
return new ClientCredentials
{
UserName =
{
UserName = Parameters.DeviceID,
Password = Parameters.DevicePassword
}
};
}
return DeviceIdManager.LoadOrRegisterDevice(CrmSvcUtil.ApplicationId, orgServiceConfig.CurrentIssuer.IssuerAddress.Uri);
}
private static IServiceConfiguration GetConfiguration()
{
IServiceConfiguration configuration = null;
try
{
configuration = (ServiceConfiguration) ConfigurationManager.GetSection("etservice/diagnostics");
}
catch (Exception e)
{
logger.Warn("Could not load configuration section etservice/diagnostics. Using defaults", e);
}
return configuration ?? new StaticServiceConfiguration();
}
/// <summary>
/// Helper method to create a GoogleCalendarFactory
/// </summary>
/// <param name="calendarConfiguration"></param>
/// <param name="serviceConfiguration"></param>
/// <returns></returns>
private ICalendarFactory GetGoogleCalendarFactory(ICalendarConfiguration calendarConfiguration, IServiceConfiguration serviceConfiguration)
{
var googleCalendarConfiguration = calendarConfiguration as GoogleCalendarConfiguration;
if (googleCalendarConfiguration == null)
{
throw new InvalidDataException("Unable to cast calendar config to Google calendar format.");
}
var googleServiceConfiguration = serviceConfiguration as GoogleServiceConfiguration;
if (googleServiceConfiguration == null)
{
throw new InvalidDataException("Unable to cast service config to Google service format.");
}
return new GoogleCalendarFactory(googleCalendarConfiguration, googleServiceConfiguration);
}
