public ProjectBusiness(IReadRepository readRepository, IRepository repository, IWriteRepository writeRepository, IUserAccessBusiness userAccessBusiness)
{
_readRepository = readRepository;
_repository = repository;
_writeRepository = writeRepository;
_userAccessBusiness = userAccessBusiness;
}
public WriteBusiness(IWriteRepository repository, IServiceLog serviceLog)
{
_repository = repository;
_serviceLog = serviceLog;
_running = true;
Task.Factory.StartNew(Run);
}
public void Init()
{
repository = new MongoRepository (connectionString);
admin = new Admin("http://127.0.0.1:8082");
ssa = new SuperSimpleAuth ("testing_mtgdb.info",
"ae132e62-570f-4ffb-87cc-b9c087b09dfb");
ssaUser = ssa.Authenticate ("mtgdb_tester",
"test123", "127.0.0.1");
}
public NotesService(IUnitOfWork unitOfWork, IQueries queries)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
if (queries == null)
{
throw new ArgumentNullException("queries");
}
_queries = queries;
_unitOfWork = unitOfWork;
_notesRepository = _unitOfWork.Repository<Note>();
}
public ProductsController()
{
_writeRepository = DocumentDatabase.GetWriteRepository <Product>();
_readRepository = DocumentDatabase.GetReadRepository <Product>();
}
public DeleteCommand(Guid id, IWriteRepository <T> deleteRepository, IReadOnlyRepository <T> readRepository)
{
_id = id;
_deleteRepository = deleteRepository;
_readRepository = readRepository;
}
public void TestSetup()
{
read = Substitute.For <IReadRepository <User> >();
write = Substitute.For <IWriteRepository <User> >();
}
public ServiceController(IReadOnlyRepository <Service> serviceReadOnlyRepository, IWriteRepository <Service> serviceWriteRepository)
{
_serviceReadOnlyRepository = serviceReadOnlyRepository;
_serviceWriteRepository = serviceWriteRepository;
}
public UpdateRunnerCommandHandler(IWriteRepository <Domain.Coach> repository,
IHttpContextAccessor httpContext)
{
this.repository = repository;
this.httpContext = httpContext;
}
public CreateCoachCommandHandler(IWriteRepository <Domain.Coach> repository)
{
this.repository = repository;
}
public CreateDataFileConfigurationCommand(IWriteRepository<DataFileConfiguration> repository, [DataFileConfigurationRuleEngine]FileProcessorRuleEngine ruleEngine, ErrorHandler errorHandler)
: base(errorHandler)
{
_repository = repository;
_ruleEngine = ruleEngine;
}
public ChannelManager(IReadRepository <Read.Channel, int> readRepository, IWriteRepository <Write.Channel, int> writeRepository) : base(readRepository, writeRepository)
{
}
public ClienteCommandHandler(IWriteRepository <Models.Cliente> writeRepository)
{
_writeRepository = writeRepository;
}
public DeleteBlogPostCommandHandler(IWriteRepository <BlogPost> repository)
{
_repository = repository;
}
public CreateDataSourceFileCommand(IWriteRepository<DataSourceFile> repository, ErrorHandler errorHandler)
: base(errorHandler)
{
_repository = repository;
}
public FormGame(BattleshipsContext context, IReadRepository <Board> boardReadRepository, IReadRepository <Ship> shipReadRepository, IReadRepository <User> userReadRepository,
IWriteRepository <Board> boardWriteRepository, IWriteRepository <Ship> shipWriteRepository, IWriteRepository <User> userWriteRepository)
{
_boardReadRepository = boardReadRepository;
_shipReadRepository = shipReadRepository;
_userReadRepository = userReadRepository;
_boardWriteRepository = boardWriteRepository;
_shipWriteRepository = shipWriteRepository;
_userWriteRepository = userWriteRepository;
InitializeComponent();
initializationShipId = 0;
gameFinished = false;
groupBoxPlayerBoard.Text = _userReadRepository.GetById(1).Name;
playerBoard = _boardReadRepository.GetById(1).Fields;
cpuBoard = _boardReadRepository.GetById(2).Fields;
checkBoxLongShipsOrientation.Hide();
if (!_boardReadRepository.GetById(1).Initialized)
{ // plansza wymaga inicjalizacji
labelPlayerBoardInitializing.Show();
groupBoxCPUBoard.Hide();
initializationProcess = true;
labelPlayerBoardInitializing.Text = "Ustaw statek długości 1";
buttonSaveGame.Hide();
labelCpuHitsCount.Hide();
labelPlayerHitsCount.Hide();
}
else
{ // plansza była już zainicjalizowana
groupBoxCPUBoard.Show();
labelPlayerBoardInitializing.Hide();
initializationProcess = false;
buttonSaveGame.Show();
fillBoards();
labelCpuHitsCount.Show();
labelPlayerHitsCount.Show();
}
}
public UserManager(IReadRepository <Read.User, int> readRepository, IWriteRepository <Write.User, int> writeRepository) : base(readRepository, writeRepository)
{
}
public UserProfileService(IWriteRepository writeRepository, IMediator mediator, IAuthProvider authProvider)
{
_writeRepository = writeRepository;
_mediator = mediator;
_authProvider = authProvider;
}
public WriteModule (IWriteRepository repository)
{
if(bool.Parse(ConfigurationManager.AppSettings.Get ("https")))
{
this.RequiresHttps();
}
this.repository = repository;
ssa = new SuperSimpleAuth (ConfigurationManager.AppSettings.Get ("domain"),
ConfigurationManager.AppSettings.Get ("key"));
Before += ctx => {
try
{
Guid authKey = Guid.Parse(Request.Form["AuthToken"]);
User user = ssa.Validate(authKey,this.Context.Request.UserHostAddress);
if(user == null ||
!user.InRole("admin"))
{
return HttpStatusCode.Forbidden;
}
}
catch(Exception e)
{
return HttpStatusCode.ProxyAuthenticationRequired;
}
return null;
};
Post["/sets", true] = async(parameters, ct) => {
CardSet model = this.Bind<CardSet>();
CardSet set = await repository.AddCardSet(model);
if(set == null)
{
return Response.AsJson("false",
Nancy.HttpStatusCode.UnprocessableEntity);
}
//return Response.AsJson(card);
return Response.AsJson(true);
};
Post ["/sets/{id}", true] = async(parameters, ct) => {
UpdateCardModel model = this.Bind<UpdateCardModel>();
string setId = (string)parameters.id;
try
{
switch(Helper.GetSetFieldType(model.Field))
{
case "bool":
await repository.UpdateCardSet<bool>(setId, model.Field,
bool.Parse(model.Value ?? "false"));
break;
case "int":
await repository.UpdateCardSet<int>(setId, model.Field,
int.Parse(model.Value ?? "0"));
break;
case "string":
await repository.UpdateCardSet<string>(setId, model.Field,
model.Value ?? "");
break;
case "string[]":
await repository.UpdateCardSet<string[]>(setId, model.Field,
model.Value.Split(','));
break;
case "DateTime":
await repository.UpdateCardSet<DateTime>(setId, model.Field,
DateTime.Parse(model.Value));
break;
default:
return Response.AsJson("false",
Nancy.HttpStatusCode.UnprocessableEntity);
}
}
catch(Exception e)
{
throw e;
// return Response.AsJson(false,
// Nancy.HttpStatusCode.UnprocessableEntity);
}
return Response.AsJson(true,
Nancy.HttpStatusCode.OK);
};
Post["/cards", true] = async(parameters, ct) => {
Card model = this.Bind<Card>();
Card card = await repository.AddCard(model);
if(card == null)
{
return Response.AsJson("false",
Nancy.HttpStatusCode.UnprocessableEntity);
}
//return Response.AsJson(card);
return Response.AsJson(true);
};
Post ["/cards/{id}", true] = async(parameters, ct) => {
UpdateCardModel model = this.Bind<UpdateCardModel>();
int mvid = (int)parameters.id;
try
{
switch(Helper.GetCardFieldType(model.Field))
{
case "bool":
await repository.UpdateCardField<bool>(mvid,model.Field,
bool.Parse(model.Value ?? "false"));
break;
case "int":
await repository.UpdateCardField<int>(mvid,model.Field,
int.Parse(model.Value ?? "0"));
break;
case "string":
await repository.UpdateCardField<string>(mvid,model.Field,
model.Value ?? "");
break;
case "string[]":
await repository.UpdateCardField<string[]>(mvid,model.Field,
model.Value.Split(','));
break;
case "DateTime":
await repository.UpdateCardField<DateTime>(mvid,model.Field,
DateTime.Parse(model.Value));
break;
default:
return Response.AsJson("false",
Nancy.HttpStatusCode.UnprocessableEntity);
}
}
catch(Exception e)
{
throw e;
// return Response.AsJson(false,
// Nancy.HttpStatusCode.UnprocessableEntity);
}
return Response.AsJson(true,
Nancy.HttpStatusCode.OK);
};
Post ["/cards/{id}/rulings", true] = async(parameters, ct) => {
List<Ruling> rulings = this.Bind<List<Ruling>>();
int mvid = (int)parameters.id;
try
{
await repository.UpdateCardRulings(mvid,rulings.ToArray());
}
catch(Exception e)
{
throw e;
}
return Response.AsJson("true");
};
Post ["/cards/{id}/formats", true] = async(parameters, ct) => {
List<Format> formats = this.Bind<List<Format>>();
int mvid = (int)parameters.id;
try
{
await repository.UpdateCardFormats(mvid,formats.ToArray());
}
catch(Exception e)
{
throw e;
}
return Response.AsJson("true");
};
}
public ReadWriteRepository(IReadRepository <TEntity> readRepo, IWriteRepository <TEntity> writeRepo)
{
_readRepo = readRepo;
_writeRepo = writeRepo;
}
protected EntityService(IRepositoryFactory <TEntity> repositoryFactory, IUnitOfWork unitOfWork)
{
ReadRepository = repositoryFactory.GetRead(unitOfWork);
WriteRepository = repositoryFactory.GetWrite(unitOfWork);
}
public TransferOnHandler(IWriteRepository <TransferOn> repository
, IEnumerable <IValidator <TransferOn> > validators)
{
this.repository = repository;
this.validators = validators;
}
public FluentCassandraAssertion(IWriteRepository writeRepository)
{
_writeRepository = writeRepository;
}
/// <inheritdoc />
public PatchService(IMapper mapper, IReadRepository <TEntity> readRepository, IWriteRepository <TEntity> writeRepository, IModelValidator <TModel> validator)
{
_mapper = mapper;
_readRepository = readRepository;
_writeRepository = writeRepository;
_validator = validator;
}
public VehicleController(IReadOnlyRepository <Vehicle> VehicleReadOnlyRepository, IWriteRepository <Vehicle> VehicleWriteRepository, IReadOnlyRepository <VehicleHistoryAdapter> HistoryReadOnlyRepository)
{
_VehicleReadOnlyRepository = VehicleReadOnlyRepository;
_VehicleWriteRepository = VehicleWriteRepository;
_HistoryReadOnlyRepository = HistoryReadOnlyRepository;
}
public static void Add <TEntity>(this TEntity entity, IWriteRepository <TEntity> repo)
where TEntity : IEntity =>
repo.Add(entity);
public LessonManager(IReadRepository <Read.Lessons, int> readRepository, IWriteRepository <Write.Leason, int> writeRepository) : base(readRepository, writeRepository)
{
}
public UserService(IReadRepository <User> userReadRepository, IWriteRepository <User> userWriteRepository)
{
_userReadRepository = userReadRepository;
_userWriteRepository = userWriteRepository;
}
public DomainErrorService(IWriteRepository<FileProcessorError> repository, FileProcessorError error)
{
_error = error;
_repository = repository;
}
public Repository(IDataSource <TEntity> dataSource, IWriteRepository <TEntity> writeRepo)
: base(dataSource)
{
_writeRepo = writeRepo;
}
public SeedDataUseCase(
IWriteRepository writeRepository)
{
_writeRepository = writeRepository;
}
public PayBillHandler(IWriteRepository <Subject> subjectRepository)
{
_subjectRepository = subjectRepository;
}
public ServiceOrderController(IReadOnlyRepository <ServiceOrder> serviceOrdeReadOnlyRepository, IWriteRepository <ServiceOrder> serviceOrderWriteRepository)
{
_serviceOrdeReadOnlyRepository = serviceOrdeReadOnlyRepository;
_serviceOrderWriteRepository = serviceOrderWriteRepository;
}
public LaboratoryService(IReadRepository readRepository, IWriteRepository writeRepository)
{
this._readRepository = readRepository;
this._writeRepository = writeRepository;
}
public WriteRepositoryTest()
{
_sandbox = new Sandbox(new SandboxOptions());
_sut = _sandbox.Resolve <IWriteRepository>();
}
public ClassroomService(IWriteRepository writeRepository, IReadRepository readRepository, IClassroomMapper classroomMapper)
{
this.writeRepository = writeRepository ?? throw new ArgumentNullException();
this.readRepository = readRepository ?? throw new ArgumentNullException();
this.classroomMapper = classroomMapper ?? throw new ArgumentNullException();
}
public BattleEndedEventHandler(IReadRepository <Battle> battlesReadRepository, IWriteRepository <Battle> battlesWriteRepository, IMediator mediator)
{
this.battlesReadRepository = battlesReadRepository;
this.battlesWriteRepository = battlesWriteRepository;
this.mediator = mediator;
}
public OwnerController(IReadOnlyRepository <Owner> ownerReadOnlyRepository, IWriteRepository <Owner> ownerWriteRepository)
{
_ownerReadOnlyRepository = ownerReadOnlyRepository;
_ownerWriteRepository = ownerWriteRepository;
}
