public async Task <IHttpActionResult> RegisterClient(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var UserId = UserManager.FindByEmail(model.Email);
//Calling provider to save data
ClientProvider.CreateUser(model);
UserManager.AddToRole(UserId.Id, "Client");
}
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
/// <summary>
///
/// </summary>
/// <param name="connectionString"></param>
/// <param name="longPollingTimeout"></param>
/// Turn it on if you know the limit will not be reached</param>
public ServiceBusOperator(string connectionString,
TimeSpan longPollingTimeout)
{
_longPollingTimeout = longPollingTimeout;
_namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
_clientProvider = new ClientProvider(connectionString, true);
}
public void Execute()
{
var stopWatch = new Stopwatch();
var isConnectionAvailable = false;
Trace.WriteLineIf(Extensibility.NBiTraceSwitch.TraceInfo, String.Format("Will try to connect to '{0}' during {1} milli-seconds.", connectionString, timeOut));
stopWatch.Start();
while (stopWatch.ElapsedMilliseconds < timeOut && !isConnectionAvailable)
{
try
{
Trace.WriteLineIf(Extensibility.NBiTraceSwitch.TraceVerbose, String.Format("Building connection string with '{0}'.", connectionString));
var sessionFactory = new ClientProvider();
var connection = sessionFactory.Instantiate(connectionString).CreateNew() as IDbConnection;
Trace.WriteLineIf(Extensibility.NBiTraceSwitch.TraceVerbose, String.Format("Trying to connect to '{0}'.", connection.ConnectionString));
connection.Open();
connection.Close();
isConnectionAvailable = true;
Trace.WriteLineIf(Extensibility.NBiTraceSwitch.TraceVerbose, String.Format("Successful connection to '{0}'.", connection.ConnectionString));
}
catch (Exception ex)
{
Trace.WriteLineIf(Extensibility.NBiTraceSwitch.TraceVerbose, String.Format("Fail to connect to '{0}': {1}", connectionString, ex.Message));
}
}
if (!isConnectionAvailable)
{
throw new NBiException(String.Format("The connection to '{0}' wasn't available after {1} milli-seconds: timeout reached!", connectionString, timeOut));
}
}
public static List <TechnicianRequirement> GetToursOfTechnicianFromService(GetToursOfTechnicianRequest getToursOfTechnicianRequest)
{
if (getToursOfTechnicianRequest == null)
{
throw new ArgumentNullException(nameof(getToursOfTechnicianRequest));
}
List <TechnicianRequirement> list = new List <TechnicianRequirement>();
List <TechnicianRequirement> tours = new List <TechnicianRequirement>();
WebToolExtendedServiceClient client = ClientProvider.ProvideTOClient(getToursOfTechnicianRequest.Environment);
Task <ServiceReference2.ResultListOfAppointmentuukIAVwv> task = client.GetTourOfTechnicianAsync(getToursOfTechnicianRequest.Ident, getToursOfTechnicianRequest.MandatorId, getToursOfTechnicianRequest.TechnicianID, getToursOfTechnicianRequest.Date, null);
ResultListOfAppointmentuukIAVwv result = task.Result;
if ((result != null) && string.IsNullOrEmpty(result.Error) && (result.DataList != null) && (result.DataList.Length > 0))
{
List <Appointment> appointments = result.DataList.Where(x => x.State != ActivationState.Deleted).ToList();
foreach (Appointment appointment in appointments)
{
List <TechnicianRequirement> appointmenttours = appointment.TechnicianRequirements.Where(y => y.TechnicianID.SourceId == getToursOfTechnicianRequest.TechnicianID.SourceId && y.State != ActivationState.Deleted).ToList();
foreach (TechnicianRequirement tour in appointmenttours)
{
tour.Appointment = appointment;
tour.Appointment.GeoLocation = GetGeoLocation(client, getToursOfTechnicianRequest.Ident, getToursOfTechnicianRequest.MandatorId, tour.Appointment.GeoLocationID);
if (tour.Appointment.GeoLocation != null)
{
tours.Add(tour);
}
}
}
list = tours.OrderBy(x => x.RealStart).ToList();
}
return(list);
}
/// <summary>
/// Creates and returns an MinIO Client with custom HTTP Client
/// </summary>
/// <returns>Client with no arguments to be used with other builder methods</returns>
public MinioClient(HttpClient httpClient)
{
Region = "";
SessionToken = "";
Provider = null;
HTTPClient = httpClient;
}
public async Task Edit_WhenAuthenticatedRequestReceivedWithInvalidModelState_ThenRedirectToReadViewActionReturned()
{
var client = ClientProvider.GetOnePreEditTestClient();
var editedClient = ClientProvider.GetOnePostEditTestClient();
_mockAuthService
.Setup(a => a.IsAuthenticated(_user))
.Returns(true);
_mockRepository
.Setup(r => r.EditAsync(client.Id, editedClient))
.ReturnsAsync(editedClient);
var controller = new ClientController(_mockAuthService.Object, _mockRepository.Object, _mockService.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = _user
}
};
controller.ModelState.AddModelError("Forename", "Forename maximum length reached");
var actual = await controller.Edit(client.Id, editedClient) as RedirectToActionResult;
Assert.IsNotNull(actual);
Assert.IsTrue(actual.ActionName == "Read");
}
public async Task Create_WhenAuthenticatedRequestReceivedWithInvalidModelState_ThenRedirectToCreateViewActionReturned()
{
var client = ClientProvider.GetOnePreCreationTestClient();
_mockAuthService
.Setup(a => a.IsAuthenticated(_user))
.Returns(true);
_mockRepository
.Setup(r => r.AddAsync(client))
.ReturnsAsync(ClientProvider.GetOnePostCreationTestClient());
var controller = new ClientController(_mockAuthService.Object, _mockRepository.Object, _mockService.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = _user
}
};
controller.ModelState.AddModelError("Forename", "Forename maximum length reached");
var actual = await controller.Create(client) as ViewResult;
Assert.IsNotNull(actual);
Assert.IsInstanceOf <ViewResult>(actual);
Assert.That("Create", Is.EqualTo(actual.ViewName));
}
/// <summary>
/// Creates NdRestApiFacade instance.
/// </summary>
/// <param name="userInfo"><see cref="UserInfo"/> instance.</param>
/// <returns>NdRestApiFacade instance.</returns>
public NdRestApiFacade CreateApiClient(UserInfo userInfo)
{
var containerWrapper = new FormattersContainerWrapper();
var contentFormattersFactory = new ContentFormattersFactory(containerWrapper);
var authenticationStorageAdapter = new InMemoryAuthenticationStorageAdapter();
var clientData = new ClientData(ndHostSettings, authenticationStorageAdapter);
var requestBuilderFactory = new RequestBuilderFactory(contentFormattersFactory, clientData);
var oauthLocker = new OAuthLocker();
var ndThreadUrlFormatHelper = new NdThreadUrlFormatHelper();
var oauthClientProvider = new OAuthClientProvider(clientData);
var oAuth = new OAuth(requestBuilderFactory,
oauthClientProvider,
contentFormattersFactory);
var oAuthFacade = new OAuthFacade(oAuth, clientData, userInfo);
oAuthFacade.RefreshTokens();
var clientProvider = new ClientProvider(oAuth, clientData, ndThreadUrlFormatHelper, oauthLocker);
// Note: it seems that we are running our tests on a single host.
return(restClients.GetOrAdd(userInfo.UserName,
new Lazy <NdRestApiFacade>(
() => new NdRestApiFacade(RestClientV1Initializer(requestBuilderFactory,
clientProvider,
contentFormattersFactory),
RestClientV2Initializer(requestBuilderFactory,
clientProvider,
contentFormattersFactory),
new CustomRestClient(requestBuilderFactory, clientProvider),
oAuthFacade)))
.Value);
}
public void Instantiate_ConnectionString_CorrectType(string connectionString, Type expectedType)
{
var factory = new ClientProvider();
var connection = factory.Instantiate(connectionString);
Assert.That(connection.CreateNew(), Is.TypeOf(expectedType));
}
/// <summary>
/// With provider for credentials and session token if being used
/// </summary>
/// <returns></returns>
public MinioClient WithCredentialsProvider(ClientProvider provider)
{
this.Provider = provider;
AccessCredentials credentials = null;
if (this.Provider is IAMAWSProvider iAMAWSProvider)
{
// Empty object, we need the Minio client completely
credentials = new AccessCredentials();
}
else
{
credentials = this.Provider.GetCredentials();
}
if (credentials == null)
{
// Unable to fetch credentials.
return(this);
}
this.AccessKey = credentials.AccessKey;
this.SecretKey = credentials.SecretKey;
bool isSessionTokenAvailable = !string.IsNullOrEmpty(credentials.SessionToken);
if ((this.Provider is AWSEnvironmentProvider ||
this.Provider is IAMAWSProvider ||
(this.Provider is ChainedProvider chainedProvider && chainedProvider.CurrentProvider is AWSEnvironmentProvider)) &&
isSessionTokenAvailable)
{
this.SessionToken = credentials.SessionToken;
}
return(this);
}
public async Task GetOne_WhenAuthenticatedUserRequestsPage_ThenDetailViewResultWithClientsReturned()
{
_mockAuthService
.Setup(a => a.IsAuthenticated(_user))
.Returns(true);
_mockRepository
.Setup(r => r.ReadAsync(1))
.ReturnsAsync(ClientProvider.GetOneTestClient());
var controller = new ClientController(_mockAuthService.Object, _mockRepository.Object, _mockService.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = _user
}
};
var actual = await controller.GetOne(1) as ViewResult;
var actualModel = actual.Model as Client;
Assert.IsNotNull(actual);
Assert.IsInstanceOf <ViewResult>(actual);
Assert.That("Detail", Is.EqualTo(actual.ViewName));
Assert.That("Alice", Is.EqualTo(actualModel.Forename));
}
public ExecutionEngineFactory(ClientProvider clientProvider, CommandProvider commandProvider, IExtensionsConfiguration config)
: base(clientProvider, commandProvider)
{
var extensions = config?.Extensions?.Where(x => typeof(IExecutionEngine).IsAssignableFrom(x.Key))?.Select(x => x.Key) ?? new Type[0];
RegisterEngines(classics.Union(extensions).ToArray());
}
public IDecorationCommandImplementation Get(IBatchRunCommand command)
{
var sessionFactory = new ClientProvider();
var connection = sessionFactory.Instantiate(command.ConnectionString).CreateNew() as IDbConnection;
var directory = AssemblyDirectory;
var filename = string.Format("NBi.Core.{0}.dll", command.Version);
var filepath = string.Format("{0}\\{1}", directory, filename);
if (!File.Exists(filepath))
{
throw new InvalidOperationException(string.Format("Can't find the dll for version '{0}' in '{1}'. NBi was expecting to find a dll named '{2}'.", "2014", directory, filename));
}
var assembly = Assembly.LoadFrom(filepath);
var types = assembly.GetTypes()
.Where(m => m.IsClass && m.GetInterface("IBatchRunnerFatory") != null);
if (types.Count() == 0)
{
throw new InvalidOperationException(string.Format("Can't find a class implementing 'IBatchRunnerFatory' in '{0}'.", assembly.FullName));
}
if (types.Count() > 1)
{
throw new InvalidOperationException(string.Format("Found more than one class implementing 'IBatchRunnerFatory' in '{0}'.", assembly.FullName));
}
var batchRunnerFactory = Activator.CreateInstance(types.ElementAt(0)) as IBatchRunnerFatory;
var batchRunner = batchRunnerFactory.Get(command, connection);
return(batchRunner);
}
void Disconnect()
{
if (Scene != null && Scene.Connected)
{
ClientProvider.DisconnectScene(SceneId);
}
}
/// <summary>
///
/// </summary>
/// <param name="connectionString"></param>
/// <param name="longPollingTimeout"></param>
/// Turn it on if you know the limit will not be reached</param>
public ServiceBusOperator(string connectionString,
TimeSpan longPollingTimeout)
{
_longPollingTimeout = longPollingTimeout;
_namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
_clientProvider = new ClientProvider(connectionString, true);
}
public static void ExampleToServerConsole()
{
ClientProvider clientProvider = new ClientProvider();
//if you want connect to asp.net or asp core server use this line because those servers just support websocket for duplex connections
clientProvider.ProtocolType = SignalGo.Client.ClientManager.ClientProtocolType.WebSocket;
//"asp.net mvc example" server port is 10012
var service = clientProvider.RegisterServerService <MyTestServices.ServerServices.HelloWorldService>(clientProvider);
clientProvider.RegisterClientService <MyCallback>();
clientProvider.Connect("http://localhost:9674/SignalGo");
//var service = new MyTestServices.HttpServices.HelloWorldService("http://localhost:9674");
var streamService = new MyTestServices.HttpServices.TestStreamService("http://localhost:9674");
var downloadImage = streamService.DownloadProfileImage(1, "H:\\json.txt");
var length = int.Parse(streamService.ResponseHeaders["content-length"]);
var bytes = new List <byte>();
int pos = 0;
while (pos != length)
{
var readb = new byte[length - pos];
var readCount = downloadImage.Stream.Read(readb, length - pos);
pos += readCount;
bytes.AddRange(readb.ToList().GetRange(0, readCount));
}
var fileData = Encoding.UTF8.GetString(bytes.ToArray());
var loginResult = service.Login("ali yousefi");
var callbackResult = service.CallClientService("ali", "yousefi");
Console.WriteLine("login called:");
Console.WriteLine(loginResult);
Console.WriteLine(callbackResult);
}
// DELETE: api/Configuration/5
public HttpResponseMessage Delete(int id)
{
var provider = new ClientProvider(_dbInfo);
var deleted = provider.Delete(id);
return(Request.CreateResponse(HttpStatusCode.OK, deleted));
}
public static List <TechnicianRequirement> TestGetTourOfTechnician(Ident ident, int mandatorId, ID technicianID, DateTime date, VueTOView.Common.Environment environment)
{
List <TechnicianRequirement> list = new List <TechnicianRequirement>();
List <TechnicianRequirement> tours = new List <TechnicianRequirement>();
WebToolExtendedServiceClient client = ClientProvider.ProvideTOClient(environment);
Task <ServiceReference2.ResultListOfAppointmentuukIAVwv> task = client.GetTourOfTechnicianAsync(ident, mandatorId, technicianID, date, null);
ResultListOfAppointmentuukIAVwv result = task.Result;
if ((result != null) && string.IsNullOrEmpty(result.Error) && (result.DataList != null) && (result.DataList.Length > 0))
{
List <Appointment> appointments = result.DataList.Where(x => x.State != ActivationState.Deleted).ToList();
foreach (Appointment appointment in appointments)
{
List <TechnicianRequirement> appointmenttours = appointment.TechnicianRequirements.Where(y => y.TechnicianID.SourceId == technicianID.SourceId && y.State != ActivationState.Deleted).ToList();
foreach (TechnicianRequirement tour in appointmenttours)
{
tour.Appointment = appointment;
tour.Appointment.GeoLocation = TestGetGeoLocation(client, ident, mandatorId, tour.Appointment.GeoLocationID);
if (tour.Appointment.GeoLocation != null)
{
tours.Add(tour);
}
}
}
list = tours.OrderBy(x => x.RealStart).ToList();
}
return(list);
}
public async Task Create_WhenAuthenticatedRequestReceived_ThenRedirectToReadViewActionReturned()
{
var client = ClientProvider.GetOnePreCreationTestClient();
_mockAuthService
.Setup(a => a.IsAuthenticated(_user))
.Returns(true);
_mockRepository
.Setup(r => r.AddAsync(client))
.ReturnsAsync(ClientProvider.GetOnePostCreationTestClient());
var controller = new ClientController(_mockAuthService.Object, _mockRepository.Object, _mockService.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = _user
}
};
var actual = await controller.Create(client) as RedirectToActionResult;
Assert.IsNotNull(actual);
Assert.IsTrue(actual.ActionName == "Read");
Assert.IsTrue(actual.ControllerName == "Client");
}
/// <summary>
/// Creates and returns an MinIO Client
/// </summary>
/// <returns>Client with no arguments to be used with other builder methods</returns>
public MinioClient()
{
Region = "";
SessionToken = "";
Provider = null;
HTTPClient = new HttpClient();
}
private void OnDestroy()
{
if (DisconnectOnDestroy)
{
Debug.Log("Destroy!!");
ClientProvider.CloseClient();
}
}
/// <summary>
///
/// </summary>
/// <param name="connectionString"></param>
/// <param name="longPollingTimeout"></param>
/// <param name="cacheClients">False by default to prevent hitting the 100 limit.
/// Turn it on if you know the limit will not be reached</param>
public ServiceBusOperator(string connectionString,
TimeSpan longPollingTimeout,
bool cacheClients = false)
{
_longPollingTimeout = longPollingTimeout;
_connectionString = connectionString;
_namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
_clientProvider = new ClientProvider(connectionString, cacheClients);
}
protected IDbCommand CreateCommand()
{
var factory = new ClientProvider();
var conn = factory.Instantiate(ConnectionString).CreateNew() as IDbConnection;
var cmd = conn.CreateCommand();
return(cmd);
}
private void startClient(int i)
{
_clientProvider = new ClientProvider(_wordProvider, _wordProvider.GetRandomDictionary(3));
_clientProvider.NewMessage += _clientProvider_NewMessage;
Thread newThread = new Thread(new ParameterizedThreadStart(_clientProvider.StartClient));
newThread.Name = Guid.NewGuid().ToString();
newThread.Start(_serverParam);
}
public async Task ExcluindoPorIdInvalida()
{
using (HttpClient client = new ClientProvider().Client)
{
HttpResponseMessage response = await client.DeleteAsync(string.Concat(urlBase, "/0"));
response.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
}
public virtual IDbCommand GetCommand()
{
var conn = new ClientProvider().Instantiate(GetConnectionString()).CreateNew() as IDbConnection;
var cmd = conn.CreateCommand();
cmd.CommandText = GetQuery();
return(cmd);
}
public async Task TentandoAlterarUsuarioNulo()
{
using (HttpClient client = new ClientProvider().Client)
{
HttpResponseMessage response = await client.PutAsync(string.Concat(urlBase, "/0"), new StringContent("", Encoding.UTF8, "application/json"));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
}
public async Task GetUsuarioPorId()
{
using (HttpClient client = new ClientProvider().Client)
{
HttpResponseMessage response = await client.GetAsync(string.Concat(urlBase, "/-5"));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
}
public async Task LoginSemSenha()
{
using (HttpClient client = new ClientProvider().Client)
{
HttpResponseMessage response = await client.GetAsync(string.Concat(urlBase, "/nome", ""));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
}
public void Instantiate_AddCustom_CorrectType()
{
var factory = new ClientProvider();
factory.RegisterFactories(new[] { typeof(FakeSessionFactory) });
var connection = factory.Instantiate("fake://MyConnectionString");
Assert.IsInstanceOf <FakeSession>(connection);
}
public void Add_TwiceTheSame_Exception()
{
var factory = new ClientProvider();
factory.RegisterFactories(new[] { typeof(FakeSessionFactory) });
var ex = Assert.Throws <ArgumentException>(() => factory.RegisterFactories(new[] { typeof(FakeSessionFactory) }));
Assert.That(ex.Message.Contains(typeof(FakeSessionFactory).Name));
}
/// <summary>
/// Initializes a new instance of the <see cref="OAuthService"/> class.
/// </summary>
public OAuthService()
{
var clientProvider = new ClientProvider();
var tokenProvider = new TokenProvider();
var passwordProvider = new PasswordProvider();
var scopes = new List<string>();
this.oAuthProvider = OAuthFactory.BuildOAuthProvider(clientProvider, tokenProvider, scopes, passwordProvider: passwordProvider);
}
/// <summary>
/// Authenticates the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="response">The response.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="secure">if set to <c>true</c> [secure].</param>
/// <param name="requiresTransportLayerSecurity">if set to <c>true</c> [requires transport layer security].</param>
/// <param name="scope">The scope.</param>
/// <returns></returns>
public IIdentity Authenticate(IncomingWebRequestContext request, OutgoingWebResponseContext response, object[] parameters, bool secure, bool requiresTransportLayerSecurity, string scope, bool allowAnonymous)
{
var clientProvider = new ClientProvider();
var passwordProvider = new PasswordProvider();
var tokenProvider = new TokenProvider();
var scopes = new List<string>();
var oAuthProvider = OAuthFactory.BuildOAuthProvider(clientProvider, tokenProvider, scopes, passwordProvider: passwordProvider);
var token = request.Headers["Authorization"];
if (string.IsNullOrWhiteSpace(token))
{
token = HttpContext.Current.Request.QueryString["access_token"];
}
else
{
if (!string.IsNullOrWhiteSpace(token) && token.StartsWith("OAuth") && token.Contains(" "))
{
var splitToken = token.Split(' ');
if (splitToken.Length > 1)
{
token = splitToken[1];
}
}
}
var authentication = oAuthProvider.VerifyToken(token, scope);
if (authentication.ErrorCode != ErrorCode.None)
{
if (allowAnonymous)
{
return null;
}
var errorCode = authentication.StatusCode();
var oauthError = authentication.Error();
if (errorCode == HttpStatusCode.Unauthorized)
{
response.Headers.Add(HttpResponseHeader.WwwAuthenticate, string.Format("OAuth realm='PollMe Service', error='{0}'", oauthError));
}
throw new WebFaultException<string>(oauthError, authentication.StatusCode());
}
return new GenericIdentity("Authorized User", "OAuth2");
}
