Factory()
{
var personProjectRepository = new Mock <IPersonProjectRepository>();
var projectRepository = new Mock <IProjectRepository>();
var personUserGroupRepository = new Mock <IPersonUserGroupRepository>();
var userGroupRepository = new Mock <IUserGroupRepository>();
var personRestrictionRoleRepository = new Mock <IPersonRestrictionRoleRepository>();
var restrictionRoleRepository = new Mock <IRestrictionRoleRepository>();
var personProjectHistoryRepository = new Mock <IPersonProjectHistoryRepository>();
var privilegeService = new Mock <IPrivilegeService>();
var personService = new Mock <IPersonService>();
var logger = new Mock <ILogger <PersonProjectService> >();
var personCreatedByCache = new PersonCreatedByCache(111);
var service = new PersonProjectService(
personProjectRepository.Object,
projectRepository.Object,
privilegeService.Object,
personProjectHistoryRepository.Object,
personService.Object,
logger.Object,
personCreatedByCache);
return(service, personProjectRepository, projectRepository, personUserGroupRepository, userGroupRepository,
personRestrictionRoleRepository, restrictionRoleRepository, personProjectHistoryRepository,
personService, personCreatedByCache);
}
public PersonServiceTests()
{
_personRepository = new Mock <IPersonRepository>();
_graphService = new Mock <IGraphService>();
_projectRepository = new Mock <IProjectRepository>();
_personProjectRepository = new Mock <IPersonProjectRepository>();
_personServiceLogger = new Mock <ILogger <PersonService> >();
_personCreatedByCache = new PersonCreatedByCache(111);
_service = new PersonService(
_personRepository.Object,
_graphService.Object,
_projectRepository.Object,
_personCreatedByCache,
_personProjectRepository.Object,
_personServiceLogger.Object);
}
public static (AccessService, Mock <IGraphService>) Factory(QueueReceiverServiceContext context)
{
var personCreatedByCache = new PersonCreatedByCache(111)
{
Username = "******"
};
var personRepository = new PersonRepository(context);
var graphServiceMock = new Mock <IGraphService>();
var projectRepositoryMock = new Mock <IProjectRepository>();
var personProjectRepositoryMock = new Mock <IPersonProjectRepository>();
var personServiceLoggerMock = new Mock <ILogger <PersonService> >();
var personService = new PersonService(personRepository,
graphServiceMock.Object,
projectRepositoryMock.Object,
personCreatedByCache,
personProjectRepositoryMock.Object,
personServiceLoggerMock.Object);
var personProjectRepository = new PersonProjectRepository(context);
var projectRepository = new ProjectRepository(context);
var personUserGroupRepository = new PersonUserGroupRepository(context);
var userGroupRepository = new UserGroupRepository(context);
var personRestrictionRoleRepository = new PersonRestrictionRoleRepository(context);
var restrictionRoleRepository = new RestrictionRoleRepository(context);
var privilegeService = new PrivilegeService(restrictionRoleRepository, personRestrictionRoleRepository, userGroupRepository, personUserGroupRepository, personCreatedByCache);
var personProjectHistoryRepository = new PersonProjectHistoryRepository(context);
var plantRepository = new PlantRepository(context);
var plantService = new PlantService(plantRepository);
var AccessServiceloggerMock = new Mock <ILogger <AccessService> >();
var personProjectServiceLoggerMock = new Mock <ILogger <PersonProjectService> >();
var personProjectService = new PersonProjectService(
personProjectRepository,
projectRepository,
privilegeService,
personProjectHistoryRepository,
personService,
personProjectServiceLoggerMock.Object,
personCreatedByCache);
var service = new AccessService(personService, personProjectService, plantService, AccessServiceloggerMock.Object, context, personCreatedByCache);
return(service, graphServiceMock);
}
public AccessServiceTests()
{
var personCreatedByCache = new PersonCreatedByCache(111)
{
Username = "******"
};
_personService = new Mock <IPersonService>();
_personProjectService = new Mock <IPersonProjectService>();
_plantService = new Mock <IPlantService>();
_unitOfWork = new Mock <IUnitOfWork>();
_logger = new Mock <ILogger <AccessService> >();
_service = new AccessService(
_personService.Object,
_personProjectService.Object,
_plantService.Object,
_logger.Object,
_unitOfWork.Object,
personCreatedByCache);
}
static async Task Main(string[] args)
{
var plants = new List <string>();
if (args.Length > 1)
{
Console.WriteLine(@"Error: Invalid number of arguments.");
return;
}
if (args.Length == 1)
{
var argPlants = args[0].Split(',');
foreach (var plant in argPlants)
{
if (!plant.StartsWith("PCS$"))
{
Console.WriteLine(@"Error: Plant names must start with 'PCS$'");
return;
}
plants.Add(plant);
}
}
var path = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName);
var config = new ConfigurationBuilder()
.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
.AddJsonFile($"{path}\\hosting.json", false, true)
.AddUserSecrets <Program>()
.Build();
var removeUserAccess = bool.Parse(config["RemoveUserAccessEnabled"]);
var personCreatedById = long.Parse(config["PersonCreatedById"], CultureInfo.InvariantCulture);
var personCreatedByCache = new PersonCreatedByCache(personCreatedById);
var graphSettings = new GraphSettings();
config.Bind(nameof(GraphSettings), graphSettings);
//setup our DI
var serviceCollection = new ServiceCollection()
.AddLogging(loggingBuilder =>
{
loggingBuilder.AddConfiguration(config.GetSection("Logging"));
loggingBuilder.AddConsole();
})
.AddApplicationInsightsTelemetryWorkerService(config["ApplicationInsights:InstrumentationKey"])
.AddSingleton <ISyncService, SyncService>()
.AddSingleton(personCreatedByCache)
.AddSingleton(graphSettings)
.AddServices()
.AddRepositories()
.AddDbContext(config["ConnectionString"]);
var services = serviceCollection.BuildServiceProvider();
var logger = services.GetRequiredService <ILogger <Program> >();
var syncService = services.GetService <ISyncService>();
try
{
await syncService.StartAccessSync(plants, removeUserAccess);
}
catch (Exception e)
{
logger.LogError($"[GroupSync Error] : {e.Message}");
logger.LogError(e.StackTrace);
}
// Take a break to allow AI to finish logging.
await Task.Delay(10000);
}
