public DemoController(IDbConnection connection, ITodoItemRepository repository, ITodoService service, IQueryHandler <GetAllTodoQuery, IEnumerable <TodoItem> > queryHandler)
{
_connection = connection;
_repository = repository;
_service = service;
_queryHandler = queryHandler;
}
public TodoItemService(ITodoItemRepository todoItemRepository, ITodoListRepository todoListRepository, ITodoPersistentChanges todoUnitOfWork, IMapper mapper)
{
_todoItemRepository = todoItemRepository;
_todoListRepository = todoListRepository;
_todoUnitOfWork = todoUnitOfWork;
_mapper = mapper;
}
public GetAllTodosQueryHandler(
ITodoItemRepository todoItemRepository,
ILogger logger)
{
_todoItemRepository = todoItemRepository;
_logger = logger;
}
public ExportTodosQueryHandler(IApplicationDbContext context, IMapper mapper, ICsvFileBuilder fileBuilder, ITodoItemRepository todoItemRepository)
{
_context = context;
_mapper = mapper;
_fileBuilder = fileBuilder;
_todoItemRepository = todoItemRepository;
}
public DeleteTodoHandlerTests()
{
_todoItemRepository = Substitute.For <ITodoItemRepository>();
_busPublisher = Substitute.For <IBusPublisher>();
_context = Substitute.For <ICorrelationContext>();
_commandHandler = new DeleteTodoHandler(_todoItemRepository, _busPublisher);
}
public NewTodoItemViewModel(ITodoItemRepository todoItemRepository)
{
_todoItemRepository = todoItemRepository;
Item = new TodoItem
{
Due = DateTime.Now.AddDays(1),
};
}
public TodoItemService(IUnitOfWork uow, ITodoItemRepository todoItemRepository)
{
_todoItemRepository = todoItemRepository;
db = uow;
var config = new MapperConfiguration(cfg => { cfg.CreateMap <TodoItemEntity, TodoItemDTO>(); });
_mapper = config.CreateMapper();
}
public TodoItemViewModel(IMvxNavigationService navigationService, IUserStorageHelper storage, ICancelDialogService cancelDialogService,
IValidationHelper validationHelper, ITodoItemRepository todoItemRepository, IDialogsHelper dialogsHelper, ITodoItemService todoItemService)
: base(navigationService, storage, dialogsHelper, cancelDialogService)
{
_validationHelper = validationHelper;
_todoItemRepository = todoItemRepository;
_todoItemService = todoItemService;
}
public static void AddNewTodoItem(ITodoItemRepository repository, string description)
{
repository.AddTodoItem(new Models.TodoItem
{
Description = description
});
repository.SaveChanges();
}
public MainViewModel(ITodoItemRepository todoItemRepository)
{
_todoItemRepository = todoItemRepository;
_todoItemRepository.OnItemAdded += (sender, item) => Items.Add(CreateTodoItemViewModel(item));
_todoItemRepository.OnItemUpdated += (sender, item) => Task.Run(async() => await LoadData());
Task.Run(async() => await LoadData());
}
public TodoItemService(ITodoItemRepository todoItemRepository,
ITodoListRepository todoListRepository,
IMapper mapper)
{
_todoItemRepository = todoItemRepository;
_todoListRepository = todoListRepository;
_mapper = mapper;
}
public TodoScheduler(
IWebExtensionsApi webExtensionApi,
ITodoItemRepository repository,
ILogger <TodoScheduler> logger)
{
_webExtensionApi = webExtensionApi;
_repository = repository;
_logger = logger;
}
public MainWindowViewModel(ITodoItemRepository todoItemRepository)
{
this.todoItemRepository = todoItemRepository;
AddNewItemCommand = new SimpleCommand(AddNewItem);
CancelChangesCommand = new SimpleCommand(RefreshChanges);
updater = new Synchronizer<MainWindowViewModel>(() => PropertyChanged);
TodoItems = new ObservableCollection<TodoItemViewModel>();
RefreshChanges();
}
private static async Task InitializeDatabaseAsync(ITodoItemRepository repository)
{
var sessionList = await repository.ListAsync();
if (!sessionList.Any())
{
await repository.AddAsync(GetTestTodos());
}
}
public UserManager(IApplicationUserRepository applicationUserRepository,
IMapper mapper,
UserSearchCriteria searchCriteria,
ITodoItemRepository todoItemRepository,
IEmailManager emailManager) : base(applicationUserRepository, mapper, searchCriteria)
{
this.todoItemRepository = todoItemRepository;
this.emailManager = emailManager;
}
public MainPageViewModel(INavigationService navigationService, ITodoItemRepository todoItemRepository)
: base(navigationService)
{
Title = "Main Page";
_navigationService = navigationService;
this.repository = todoItemRepository;
AddToDoItemCommand = new DelegateCommand(OnAddItem);
//Items = new ObservableCollection<TodoItem>();
}
public TodoListViewModel()
{
repository = (ITodoItemRepository)App.UnitOfWork.GetRepository <TodoItem>();
TodoItems = new ObservableCollection <TodoItem>();
CreateItemCommand = new Command(CreateItem);
DeleteItemCommand = new Command(DeleteItem);
AddItemCommand = new Command(AddItem);
UpdateItemCommand = new Command(UpdateItem);
}
public TodoItemFacade(
ITodoItemRepository todoItemRepository,
IUserRepository userRepository,
IMapper mapper,
IUnitOfWorkProvider unitOfWorkProvider)
{
this.todoItemRepository = todoItemRepository;
this.userRepository = userRepository;
this.mapper = mapper;
this.unitOfWorkProvider = unitOfWorkProvider;
}
public TodoApp(MobileServiceClient client,
ISQLiteDBPathProvider sqliteDBPathProvider,
IAuthenticator authenticator,
ITodoItemRepository todoItemRepository,
IDataSynchronizer dataSynchronizer)
{
this.Client = client;
this.Authenticator = authenticator;
this.SQLiteDBPathProvider = sqliteDBPathProvider;
this.TodoItemRepository = todoItemRepository;
this.DataSynchronizer = dataSynchronizer;
}
public TodoItemMutation(ITodoItemRepository repo)
{
this.repo = repo;
Field <TodoItemType>(
"addTodo",
description: "Adds a todo to the database",
arguments: new QueryArguments
{
new QueryArgument <TodoItemInputType>()
{
Name = "todo"
}
},
resolve: context =>
{
var task = context.GetArgument <TodoItem>("todo");
return(repo.Add(task));
}
);
Field <TodoItemType>(
"updateTodo",
description: "Updates a todo in the database",
arguments: new QueryArguments
{
new QueryArgument <TodoItemInputType>()
{
Name = "todo"
}
},
resolve: context =>
{
return(repo.Update(context.GetArgument <TodoItem>("todo")));
}
);
Field <BooleanGraphType>(
"deleteTodo",
description: "Deletes a todo from the database",
arguments: new QueryArguments
{
new QueryArgument <StringGraphType>()
{
Name = "todoId"
}
},
resolve: context =>
{
return(repo.Delete(context.GetArgument <string>("todoId")));
}
);
}
public TodoItemViewModel(ITodoItemRepository todoItemRepository)
{
this.todoItemRepository = todoItemRepository;
SaveCommand = new SimpleCommand(Save, CanSave);
DeleteCommand = new SimpleCommand(Delete);
synchronizer = new Synchronizer<TodoItemViewModel>(() => PropertyChanged);
validations = new Dictionary<string, IValidation>
{
{"Description", new Validation(() => !string.IsNullOrEmpty(Description), "Cannot have an empty description.")},
{"DueDate", new Validation(() => DueDate >= DateTime.Today, "Due Date must occur on or after today.")}
};
}
protected override void Dispose(
bool disposing
)
{
if (disposing)
{
repo = null;
userMgr = null;
logger = null;
}
base.Dispose(disposing);
}
public TodoItemListViewModel(IMvxNavigationService navigationService, ITodoItemService todoItemService,
IUserStorageHelper storage, ITodoItemRepository todoItemRepository)
: base(navigationService, storage)
{
_todoItemRepository = todoItemRepository;
_todoItemService = todoItemService;
ShowMenuCommand = new MvxAsyncCommand(async()
=> await _navigationService.Navigate <MenuViewModel>());
AddTodoItemCommand = new MvxAsyncCommand <TodoItem>(AddTodoItem);
SelectTodoItemCommand = new MvxAsyncCommand <TodoItem>(SelectTodoItem);
RefreshTodoItemsCommand = new MvxCommand(RefreshTodoItems);
}
public UserType(ITodoItemRepository todoRepo)
{
Name = nameof(UserType);
Field(u => u.Id, type: typeof(IdGraphType));
Field(u => u.FirstName);
Field(u => u.LastName);
Field(u => u.Name);
Field(u => u.Email);
Field(u => u.PhoneNumber);
Field(u => u.Password);
Field <AddressType>("address", nameof(AddressType));
Field <ListGraphType <TodoItemType> >("todos", resolve: context => todoRepo.FetchTodosForUser(context.Source.Id));
}
public TodoModule(ITodoItemRepository repository)
: base("/todo")
{
Get["/", true] = async (_, ct) => await repository.GetAll();
Post["/", true] = async (_, ct) =>
{
var item = this.Bind<TodoItem>();
await repository.Store(item);
return Negotiate.WithModel(item).WithStatusCode(HttpStatusCode.Created);
};
Put["/{id*}", true] = async (args, ct) =>
{
string id = args.id;
var item = await repository.GetById(id);
if (item == null)
{
return HttpStatusCode.NotFound;
}
var newItem = this.Bind<TodoItem>();
item.Title = newItem.Title;
item.IsCompleted = newItem.IsCompleted;
return item;
};
Delete["/{id*}", true] = async (args, ct) =>
{
string id = args.id;
var item = await repository.GetById(id);
if (item == null)
{
return HttpStatusCode.NotFound;
}
repository.Delete(item);
return HttpStatusCode.OK;
};
}
public TodoItemQuery(ITodoItemRepository repo)
{
this.repo = repo;
Field <ListGraphType <TodoItemType> >("allTodos", description: "Gets all todos from the database", resolve: context => repo.FetchAll());
Field <TodoItemType>(
name: "todo",
description: "Gets a single todo based on ID",
arguments: new QueryArguments(
new QueryArgument <IdGraphType> {
Name = "id"
}
),
resolve: context => repo.Fetch(context.GetArgument <string>("id"))
);
}
protected BaseServiceTestConfiguration()
{
Mapper = new MapperConfiguration(cfg => { cfg.AddMaps(typeof(TodoItemProfile)); }).CreateMapper();
var configurationBody = new Dictionary <string, string>
{
{ "JwtConfiguration:SecretKey", "Super secret token key" }
};
Configuration = new ConfigurationBuilder()
.AddInMemoryCollection(configurationBody)
.Build();
TodoListRepository = Substitute.For <ITodoListRepository>();
TodoItemRepository = Substitute.For <ITodoItemRepository>();
ClaimService = Substitute.For <IClaimService>();
ClaimService.GetUserId().Returns(new Guid().ToString());
}
public TodoController(
ITodoItemRepository repo,
UserManager <AppUser> userMgr,
ILogger <TodoController> logger
)
{
if (repo == null)
{
throw new ArgumentNullException(nameof(repo));
}
if (userMgr == null)
{
throw new ArgumentNullException(nameof(userMgr));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.repo = repo;
this.userMgr = userMgr;
this.logger = logger;
}
public BaseServiceTestConfiguration()
{
_mapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new TodoItemProfile());
cfg.AddProfile(new TodoListProfile());
cfg.AddProfile(new UserProfile());
}).CreateMapper();
var configurationBody = new Dictionary <string, string>
{
{ "JwtConfiguration:SecretKey", "Super secret token key" },
};
_configuration = new ConfigurationBuilder()
.AddInMemoryCollection(configurationBody)
.Build();
_todoListRepository = Substitute.For <ITodoListRepository>();
_todoItemRepository = Substitute.For <ITodoItemRepository>();
_claimService = Substitute.For <IClaimService>();
_claimService.GetUserId().Returns(new Guid().ToString());
}
/// <summary>
/// TodoController .ctor
/// </summary>
/// <param name="todoItemRepository">todoItemRepository</param>
public TodoController(ITodoItemRepository todoItemRepository)
{
_todoItemRepository = todoItemRepository;
}
public BrowseTodosForUserHandler(ITodoItemRepository repository)
{
_repository = repository;
}
public TodoGrpcService(ILogger <TodoGrpcService> logger, ITodoItemRepository repository, IBus endpointInstance)
{
this.logger = logger;
this.repository = repository;
this.endpointInstance = endpointInstance;
}
public CreateTodoItemHandler(ITodoItemRepository repository)
{
_repository = repository;
}
private static void DeleteItems(ITodoItemRepository todoItemRepository, IEnumerable <TodoItem> selectedItems)
{
Task.WaitAll(selectedItems.Select(item => todoItemRepository.DeleteAsync(item)).ToArray());
Console.Clear();
}
public static void Configure(ApplicationDbContext context)
{
_todoItemRepository = new TodoItemRepository(context);
}
public TodoItemPresenter(ITodoItemRepository itemRepository)
{
this.itemRepository = itemRepository;
}
public ToDoItemsController(ITodoItemRepository todoItemRepository)
{
this.todoItemRepository = todoItemRepository;
}
