public ActivityController(IConfiguration configuration, UserManager <ApplicationUser> userManager)
{
_userManager = userManager;
_configuration = configuration;
_runnerRepository = new RunnerRepository(_configuration["ConnectionStrings:DB"]);
_activityRepository = new ActivityRepository(_configuration["ConnectionStrings:DB"]);
}
public RunnerRepositoryTests()
{
_request = Substitute.For <IRequest>();
_requestFactory = Substitute.For <IRequestFactory>();
_requestFactory.Create(Arg.Any <string>(), Arg.Any <Method>(), Arg.Any <bool>()).Returns(_request);
_sut = new RunnerRepository(_requestFactory);
}
public UnitOfWork()
{
var categories = new CategoryRepository();
Categories = categories;
Runners = new RunnerRepository(categories);
Database = new Database();
}
public void GetIfHasNoTimeWithCategory_should_throw_ArugmentNullException_when_given_chipId_is_null()
{
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseInMemoryDatabase(nameof(GetIfHasNoTimeWithCategory_should_throw_ArugmentNullException_when_given_chipId_is_null))
.Options;
var context = new RunnerDbContext(options);
var repository = new RunnerRepository(context);
Assert.Throws <ArgumentNullException>("chipId", () => repository.GetIfHasNoTimeWithCategory(null));
}
/// <summary>
/// Disposes coordinator, triggering feature result aggregation.
/// Each runner belonging to <see cref="RunnerRepository"/>, is disposed and its feature result is aggregated.
/// After aggregation of all results, the feature aggregator is disposed as well.
///
/// If coordinator is installed as LightBDD main coordinator, it is uninstalled as well, allowing a new one to be installed in future.
/// If coordinator is already disposed, methods does nothing.
/// </summary>
public void Dispose()
{
if (IsDisposed)
{
return;
}
IsDisposed = true;
UninstallSelf();
CollectFeatureResults();
_featureAggregator.Dispose();
RunnerRepository.Dispose();
}
public async Task GetIfHasNoTimeWithCategory_should_return_runner_with_category_with_given_chipId()
{
var databaseName = nameof(GetIfHasNoTimeWithCategory_should_return_runner_with_category_with_given_chipId);
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(string.Format(TestConfiguration.ConnectionString, databaseName))
.Options;
using (var context = new RunnerDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
await context.Runners.AddAsync(new Runner
{
ChipId = "4329085723",
Firstname = "Firstname",
Lastname = "Lastname",
Gender = Gender.Mann,
YearOfBirth = 2000,
TimeAtDestination = null,
Category = new Category
{
Name = "The Name of the Category"
}
});
await context.SaveChangesAsync();
}
using (var context = new RunnerDbContext(options))
{
var repository = new RunnerRepository(context);
var result = repository.GetIfHasNoTimeWithCategory("4329085723");
Assert.NotNull(result);
Assert.NotNull(result.Category);
Assert.Equal("Firstname", result.Firstname);
Assert.Equal("Lastname", result.Lastname);
Assert.Equal(Gender.Mann, result.Gender);
Assert.Equal(Gender.Mann, result.Gender);
Assert.Equal("The Name of the Category", result.Category.Name);
}
using (var context = new RunnerDbContext(options))
await context.Database.EnsureDeletedAsync();
}
public async Task GetIfHasNoTimeWithCategory_should_return_null_for_given_chipId_because_runners_timeAtDestiantion_is_not_null()
{
var databaseName = nameof(GetIfHasNoTimeWithCategory_should_return_null_for_given_chipId_because_runners_timeAtDestiantion_is_not_null);
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(string.Format(TestConfiguration.ConnectionString, databaseName))
.Options;
using (var context = new RunnerDbContext(options))
{
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
await context.Runners.AddAsync(new Runner
{
ChipId = "4329085723",
Firstname = "Firstname",
Lastname = "Lastname",
Gender = Gender.Mann,
YearOfBirth = 2000,
TimeAtDestination = new DateTime(2017, 10, 12, 12, 00, 00),
Category = new Category
{
Name = "The Name of the Category",
}
});
await context.SaveChangesAsync();
}
using (var context = new RunnerDbContext(options))
{
var repository = new RunnerRepository(context);
var result = repository.GetIfHasNoTimeWithCategory("4329085723");
Assert.Null(result);
}
using (var context = new RunnerDbContext(options))
await context.Database.EnsureDeletedAsync();
}
/// <summary> Creates a new <see cref="GitLabClient" /> instance. </summary>
/// <param name="hostUri"> The GitLab server to connect to. </param>
/// <param name="privateToken"> The private token to use when making requests to the GitLab API. </param>
public GitLabClient(Uri hostUri, string privateToken = null)
{
if (hostUri == null)
{
throw new ArgumentNullException(nameof(hostUri));
}
var baseUri = new Uri(hostUri, ApiPath);
_authenticator = new PrivateTokenAuthenticator(privateToken);
var clientFactory = new ClientFactory(baseUri, _authenticator);
var requestFactory = new RequestFactory(clientFactory);
Branches = new BranchRepository(requestFactory);
Builds = new BuildRepository(requestFactory);
BuildTriggers = new BuildTriggerRepository(requestFactory);
BuildVariables = new BuildVariableRepository(requestFactory);
Commits = new CommitRepository(requestFactory);
DeployKeys = new DeployKeyRepository(requestFactory);
Emails = new EmailRepository(requestFactory);
Files = new FileRepository(requestFactory);
GitLabLicense = new GitLabLicenseRepository(requestFactory);
GitLabSettings = new GitLabSettingsRepository(requestFactory);
Issues = new IssueRepository(requestFactory);
Keys = new KeyRepository(requestFactory);
Labels = new LabelRepository(requestFactory);
Licenses = new LicenseRepository(requestFactory);
MergeRequests = new MergeRequestRepository(requestFactory);
Milestones = new MilestoneRepository(requestFactory);
Namespaces = new NamespaceRepository(requestFactory);
ProjectSnippets = new ProjectSnippetRepository(requestFactory);
Repositories = new RepositoryRepository(requestFactory);
Runners = new RunnerRepository(requestFactory);
Session = new SessionRepository(requestFactory);
SystemHooks = new SystemHookRepository(requestFactory);
Tags = new TagRepository(requestFactory);
Users = new UserRepository(requestFactory);
Projects = new ProjectRepository(requestFactory);
ProjectMembers = new ProjectMemberRepository(requestFactory);
GroupMembers = new GroupMemberRepository(requestFactory);
}
public async Task GetIfHasNoTimeWithCategory_should_return_null_if_no_runner_with_given_chipId_is_found()
{
var databaseName = nameof(GetIfHasNoTimeWithCategory_should_return_null_if_no_runner_with_given_chipId_is_found);
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(string.Format(TestConfiguration.ConnectionString, databaseName))
.Options;
using (var context = new RunnerDbContext(options))
{
var repository = new RunnerRepository(context);
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();
var result = repository.GetIfHasNoTimeWithCategory("0123456789");
await context.Database.EnsureDeletedAsync();
Assert.Null(result);
}
}
private static void ImportRunners()
{
var path = string.Empty;
while (!File.Exists(path))
{
path = ReadPath("Runners");
}
var categories = ReadCategories();
var filereader = new StreamReader(path);
var json = filereader.ReadToEndClean();
var options = new DbContextOptionsBuilder <RunnerDbContext>()
.UseSqlServer(Configuration.GetConnectionString("Default"))
.Options;
using (var context = new RunnerDbContext(options))
{
var categoryRepository = new CategoryRepository(context);
var runnerRepository = new RunnerRepository(context);
var database = new Database(context);
using (var unitOfWork = new UnitOfWork(context, categoryRepository, runnerRepository, database))
{
var mapperConfiguration = GetMapperConfiguration(unitOfWork.Categories, categories.ToImmutableDictionary(c => c.ShortName, c => c.Name));
var mapper = new Mapper(mapperConfiguration);
var deserializer = new JsonDeserializer(mapper);
var runners = deserializer.Deserialize(json);
runnerRepository.AddRange(runners);
unitOfWork.Complete();
WriteLine($"{runners.Count()} Runners were successfully saved.");
}
}
}
static async Task Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(
"appsettings.json",
optional: true,
reloadOnChange: true);
var configuration = builder.Build();
string sqlConnectionString = configuration["ConnectionStrings:SqlDb"];
IActivityRepository activityRepository = new ActivityRepository(sqlConnectionString);
IRunnerRepository runnerRepository = new RunnerRepository(sqlConnectionString);
ITelemetryRepository telemetryRepository = new TelemetryRepository(sqlConnectionString);
string serviceBusConnectionString = configuration["ConnectionStrings:ServiceBus"];
string queueName = configuration["ServiceBusQueueName"];
IQueueClient queueClient = new QueueClient(serviceBusConnectionString, queueName);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
queueClient.RegisterMessageHandler(
async(message, cancellationToken) =>
{
var bytes = message.Body;
var json = Encoding.UTF8.GetString(bytes);
var content = JsonConvert.DeserializeObject <JObject>(json);
var requestType = content.Value <string>("RequestType");
Boolean completed = false;
switch (requestType)
{
case "NewTrainingRequest":
{
var runnerUsername = content.Value <string>("RunnerUsername");
Runner runner = runnerRepository.GetByUsername(runnerUsername);
var activity = new Activity()
{
Name = content.Value <string>("Name"),
IdRunner = runner.Id,
CreationDate = content.Value <DateTime>("Date"),
Location = content.Value <string>("Location"),
UriMatch = content.Value <string>("UriMatch"),
Type = 1,
State = 0
};
activityRepository.Insert(activity);
completed = true;
break;
}
case "StartTrainingRequest":
{
var idActivity = content.Value <int>("IdActivity");
var activity = activityRepository.Get(idActivity);
activity.State = 1;
activityRepository.Update(activity);
completed = true;
break;
}
/*case "ListTrainingRequest":
* {
* var runnerUsername = content.Value<string>("RunnerUsername");
* var response = new ListTrainingResponse()
* {
* Activities = activityRepository.GetByTypeAndUsername(1, runnerUsername),
* RunnerUsername = runnerUsername
* };
* var notificationJson = JsonConvert.SerializeObject(response);
* var notificationBytes = Encoding.UTF8.GetBytes(notificationJson);
* var topicMessage = new Message(notificationBytes);
*
* string serviceBusTopicConnectionString = configuration["ConnectionStrings:ServiceBusTopic"];
* string topicName = configuration["ServiceBusTopicName"];
* var topicClient = new TopicClient(serviceBusTopicConnectionString, topicName);
* await topicClient.SendAsync(topicMessage);
* await topicClient.CloseAsync();
* completed = true;
* break;
* }*/
case "DeleteActivityRequest":
{
var idActivity = content.Value <int>("IdActivity");
activityRepository.Delete(idActivity);
completed = true;
break;
}
case "UpdateSelfieRequest":
{
var uriPic = content.Value <string>("UriPic");
var idActivity = content.Value <int>("IdActivity");
var instant = content.Value <DateTime>("Instant");
telemetryRepository.Update(uriPic, idActivity, instant);
completed = true;
break;
}
default:
await queueClient.AbandonAsync(message.SystemProperties.LockToken);
break;
}
if (completed)
{
await queueClient.CompleteAsync(message.SystemProperties.LockToken);
}
else
{
await queueClient.AbandonAsync(message.SystemProperties.LockToken);
}
}, messageHandlerOptions);
//insert an option to don't make the worker always active with no messages in the queue
await Task.Delay(Timeout.Infinite);
//await queueClient.CloseAsync();
}
