private void dataGridView1_SelectionChanged(object sender, EventArgs e)
{
dataGridView2.Rows.Clear();
var selectedRows = dataGridView1.SelectedRows;
if (selectedRows.Count == 0)
{
return;
}
var row = selectedRows[0].Index;
nowSelected = rows.FirstOrDefault(c => c.Value == row).Key;
IToDoRepository repo = new ToDoRepository(Properties.Resources.DbName);
var todos = repo.GetAllTasks(nowSelected);
if (todos == null)
{
return;
}
foreach (var item in todos)
{
dataGridView2.Rows.Add(item.Text,
item.DeadLine,
item.Complete,
item.CreateDate);
}
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
_sideMenuManager = new SideMenuManager();
NavigationItem.SetLeftBarButtonItem(
new UIBarButtonItem(ConstantsHelper.Menu, UIBarButtonItemStyle.Plain, (sender, e) => {
PresentViewController(_sideMenuManager.LeftNavigationController, true, null);
}),
false);
SetupSideMenu();
var addButton = new UIBarButtonItem(UIBarButtonSystemItem.Add, NavigateToEditToDoController)
{
AccessibilityLabel = ConstantsHelper.AddNewToDoButtonAccessibilityLabel
};
NavigationItem.RightBarButtonItem = addButton;
Repository = new ToDoRepository(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), ConstantsHelper.DatabaseName));
_activeTab = new ToDoActiveViewController(Repository);
_doneTab = new ToDoDoneViewController(Repository);
ViewControllers = new[] { _activeTab, _doneTab };
SelectedIndex = 1;
}
public void Add_writes_to_database()
{
var options = new DbContextOptionsBuilder <ToDoContext>()
.UseInMemoryDatabase(databaseName: "Add_writes_to_database")
.Options;
// Run the test against one instance of the context
using (var context = new ToDoContext(options))
{
var repo = new ToDoRepository(context);
repo.Insert(new TodoItem {
Name = "Item1",
Notes = "Notes1",
Done = false,
Description = "Description of item 1"
});
context.SaveChanges();
}
// Use a separate instance of the context to verify correct data was saved to database
using (var context = new ToDoContext(options))
{
Assert.Equal(1, context.TodoItems.Count());
Assert.Equal("Item1", context.TodoItems.Single().Name);
}
}
private void RefreshItems(bool isDefault = true)
{
rows.Clear();
dataGridView1.Rows.Clear();
IToDoRepository repo = new ToDoRepository(Properties.Resources.DbName);
var todos = repo.GetAllToDoLists();
int i = 0;
foreach (var item in todos)
{
rows.Add(item.Id, i);
i++;
dataGridView1.Rows.Add(item.ToDolistText,
item.ToDo != null ? item.ToDo.Count(c => c.Complete) : 0,
item.ToDo != null ? item.ToDo.Count : 0,
item.CreateTime);
}
if (isDefault == true)
{
nowSelected = rows.FirstOrDefault().Key;
}
else
{
var tasks = repo.GetAllTasks(nowSelected);
foreach (var item in tasks)
{
dataGridView2.Rows.Add(item.Text,
item.DeadLine,
item.Complete,
item.CreateDate);
}
}
}
public ObservableCollection <ItemsViewModel> GetTaskList(string dateString)
{
ToDoModel context = new ToDoModel();
var repository = new ToDoRepository <WorkDetail>(context);
var result = new ObservableCollection <ItemsViewModel>();
IQueryable <WorkDetail> data;
if (dateString.Equals(string.Empty))
{
data = repository.GetAll();
}
else
{
data = repository.GetAll().Where((x) => x.CreationDate.ToString() == dateString && x.PlanDate == null);
}
foreach (var item in data)
{
result.Add(
new ItemsViewModel
{
Id = item.Id,
WorkContent = item.WorkContent,
PlanedDate = item.PlanDate,
Completed = item.Complete == "Y" ? true : false,
IsImportant = item.Important == "Y" ? true : false
});
}
return(result);
}
private void dataGridView1_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e)
{
var rowId = rows.First(c => c.Value == e.Row.Index).Key;
IToDoRepository repo = new ToDoRepository(Properties.Resources.DbName);
repo.Delete(rowId);
}
public BaseResult Create(RegisterViewModel model)
{
using (var repo = new ToDoRepository <User>())
{
var result = new BaseResult();
if (repo.Any(o => o.Email == model.Email))
{
result.ResultType = ResultType.BusinessError;
result.ResultMessage = $"there is already an account with this email address: {model.Email}";
return(result);
}
var hashedPassword = PasswordHelper.GetHashString(model.Password);
var dbModel = new User()
{
Email = model.Email,
LastName = model.LastName,
FirstName = model.FirstName,
Password = hashedPassword,
};
repo.Add(dbModel);
repo.SaveChanges();
return(result);
}
}
public BaseResult Save(ToDoTaskEditView model)
{
using (var repo = new ToDoRepository <ToDoList>())
{
var result = new LoginResult();
var toDoList = repo.SingleOrDefault(o => o.UserId == model.UserId && o.Id == model.ListId);
if (toDoList == null)
{
result.ResultType = ResultType.BusinessError;
result.ResultMessage = $"ToDoList not found by id:{model.ListId}";
return(result);
}
var task = new ToDoTask()
{
ToDoListId = toDoList.Id,
Desc = model.Desc,
NotificationType = model.NotificationType,
NotificationRequested = model.NotificationRequested,
NotificationDate = model.NotificationDate
};
model.Id = task.Id;
toDoList.Tasks.Add(task);
repo.SaveChanges();
return(result);
}
}
public UnitOfWork(ToDoContext context)
{
_context = context;
ToDos = new ToDoRepository(context);
Groups = new GroupRepository(context);
Users = new UserRepository(context);
}
public async Task UpdateToDoItemById_Updates_Existing()
{
using (ToDoContext dbContext = RepositoryTestHelper.NewInMemoryToDoContext())
{
await RepositoryTestHelper.SeedData(dbContext);
var toDoRepository = new ToDoRepository(dbContext, _mapper);
var updateToDoModel = new ToDoModel
{
Summary = "summary updated",
Description = "description updated",
Completed = true
};
await toDoRepository.UpdateToDoItemByIdAsync(3, updateToDoModel);
var actualResult = await dbContext.ToDoItems.FirstOrDefaultAsync(x => x.Id == 3);
var expectedResult = new ToDoItem
{
Id = 3,
Summary = updateToDoModel.Summary,
Description = updateToDoModel.Description,
Completed = updateToDoModel.Completed
};
actualResult.Should().BeEquivalentTo(expectedResult);
}
}
public void SetDone(int toDoId)
{
ToDoRepository repos = new ToDoRepository(_connectionString);
repos.SetCompleted(toDoId);
SendTasks();
}
public async Task AddToDoItemAsync_Adds_RecordToDatabase()
{
using (ToDoContext dbContext = RepositoryTestHelper.NewInMemoryToDoContext())
{
var dummyToDoRecord = new ToDoModel
{
Summary = "mock summary",
Description = "mock description",
Completed = false
};
var toDoRepository = new ToDoRepository(dbContext, _mapper);
await toDoRepository.AddToDoItemAsync(dummyToDoRecord);
var actualResult = await dbContext.ToDoItems.SingleAsync(x => x.Summary == dummyToDoRecord.Summary);
var expectedResult = new ToDoItem
{
Id = 1,
Summary = "mock summary",
Description = "mock description",
Completed = false
};
actualResult.Should().BeEquivalentTo(expectedResult);
}
}
public void LogException(string actionName, Exception ex)
{
if (ex == null)
{
return;
}
using (var repo = new ToDoRepository <ErrorLog>())
{
actionName = actionName.ShortenString(150);
var innerException = ex.GetInnerException();
var message = innerException.Message.ShortenString(200);
var stackTrace = innerException.StackTrace.ShortenString(500);
var log = new ErrorLog()
{
ActionName = actionName,
Message = message,
StackTrace = stackTrace
};
repo.Add(log);
repo.SaveChanges();
}
}
public OperationResult AddTasks(ItemsViewModel items)
{
var result = new OperationResult();
try
{
ToDoModel context = new ToDoModel();
var repository = new ToDoRepository <WorkDetail>(context);
WorkDetail entity = new WorkDetail()
{
WorkContent = items.WorkContent,
Important = items.IsImportant ? "Y" : "N",
Complete = items.Completed ? "Y" : "N",
CreationDate = DateTime.Now,
PlanDate = items.PlanedDate,
LastUpdateDate = DateTime.Now
};
repository.Create(entity);
context.SaveChanges();
result.IsSuccessful = true;
}
catch (Exception ex)
{
result.IsSuccessful = false;
result.exception = ex;
}
return(result);
}
public Startup(IHostingEnvironment env)
{
_billRepository = new BillRepository();
_shoppingRepository = new ShoppingRepository();
_peopleRepository = new PeopleRepository();
_toDoRepository = new ToDoRepository();
_householdRepository = new HouseholdRepository();
_discordService = new DiscordService(new HttpClient());
_userService = new UserService(new UserCache(), _peopleRepository);
_inviteLinkService = new InviteLinkService();
_googleTokenAuthentication = new GoogleTokenAuthentication(new HttpClient());
_recurringBillWorker = new RecurringBillWorker(_billRepository);
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
if (env.IsDevelopment())
{
builder.AddApplicationInsightsSettings(developerMode: true);
}
var discordWorker = new DiscordMessageListener(_billRepository, _shoppingRepository, _peopleRepository, _discordService);
var backgroundDiscordWorker = new Task(() => discordWorker.StartWorker());
backgroundDiscordWorker.Start();
Configuration = builder.Build();
}
public async Task SetUp()
{
_cosmosTestContext = new CosmosTestContext();
await _cosmosTestContext.SetUpAsync();
_subject = new ToDoRepository(_cosmosTestContext.GetConfiguration());
}
public void ToDoRepository_GetAll_Testcase1()
{
ToDoRepository myRepository = new ToDoRepository();
IQueryable <ToDo> myResult = myRepository.GetAll();
Assert.AreEqual(0, myResult);
}
public void ToDoRepository_GetAll_Testcase1()
{
ToDoRepository myRepository = new ToDoRepository();
List <ToDo> myResult = myRepository.GetAll();
Assert.AreEqual(0, myResult.Count);
}
/// <summary>
/// Initializes a new instance of the <see cref="ToDoController"/> class.
/// </summary>
public ToDoController()
{
IDatabaseFactory factory = new DatabaseFactory();
IToDoRepository repository = new ToDoRepository(factory);
IUnitOfWork unitOfWork = new UnitOfWork(factory);
this.service = new ToDoService(repository, unitOfWork);
}
private void DeleteToDo(ToDoViewModel viewModel)
{
ToDoRepository.DeleteModel(viewModel.ToToDoModel());
AllModels.Remove(viewModel);
LoadActiveToDoForSelectedDate(CalendarViewModel.LastSelectedDate);
LoadCompletedToDoForSelectedDate(CalendarViewModel.LastSelectedDate);
RefreshMonthDaysForToDo(viewModel);
}
private IEnumerable <ToDoViewModel> GetAllToDoFromDatabase(Func <ToDoModel, bool> predicate)
{
return(ToDoRepository
.GetAll()
.Where(x => x.UserId == Settings.CurrentUserId)
.Where(predicate)
.ToToDoViewModels(_commandResolver));
}
public void SetDoing(int toDoId)
{
ToDoRepository toDoRepos = new ToDoRepository(_connectionString);
AccountRepository accountRepos = new AccountRepository(_connectionString);
User user = accountRepos.GetUserByEmail(Context.User.Identity.Name);
toDoRepos.SetDoing(toDoId, user.Id);
SendTasks();
}
public MainViewModel()
{
DataList = new List <ToDo>();
SelectedToDo = null;
AddCommand = new StandardCommand(Add);
DeleteCommand = new StandardCommand(Delete);
UpdateCommand = new StandardCommand(Update);
_ToDoRepository = new ToDoRepository();
}
public ActionResult Delete(string Id, string group)
{
var repository = new ToDoRepository();
var item = repository.Get(group, Id);
repository.Delete(item);
return(RedirectToAction("Index"));
}
public void ToDoRepository_Create_Testcase1()
{
ToDoRepository myRepository = new ToDoRepository();
ToDo myResult = myRepository.Create();;
Assert.AreEqual(1, myResult.ID);
Assert.AreEqual("Neue Aufgabe", myResult.Title);
}
public AddToDoViewModel(INavigation navigation)
{
_navigation = navigation;
_todoValidator = new ToDoValidator();
_todo = new ToDo();
_todoRepository = new ToDoRepository();
AddToDoCommand = new Command(async() => await AddToDo());
ViewAllToDosCommand = new Command(async() => await ShowToDoList());
}
public void NewToDo(string title)
{
ToDoRepository toDoRepos = new ToDoRepository(_connectionString);
ToDo toDo = new ToDo {
Title = title, IsCompleted = false,
};
toDoRepos.AddToDo(toDo);
SendTasks();
}
public SetupToDoController()
{
var optionsBuilder = new DbContextOptionsBuilder <ToDoContext>();
optionsBuilder.UseInMemoryDatabase(databaseName: "todo");
Context = new ToDoContext(optionsBuilder.Options);
var repo = new ToDoRepository(Context);
Controller = new ToDoController(repo);
}
private ToDoService GetToDoService(MsSqlLiteDatabaseContext context, List <ToDoDbModel> toDos)
{
context.Database.OpenConnection();
context.Database.EnsureCreated();
context.ToDos.AddRange(toDos);
context.SaveChanges();
var toDoRepository = new ToDoRepository(context, kernel.Get <IToDoEntityConverter>());
return(new ToDoService(toDoRepository));
}
public void ToDoRepository_Update_Testcase1()
{
ToDoRepository myRepository = new ToDoRepository();
ToDo myTestToDo = myRepository.Create();
myTestToDo.Title = "Test1";
myRepository.Update(myTestToDo);
Assert.AreEqual("Test1", myTestToDo.Title);
}
public void ToDoRepository_Delete_Testcase1()
{
ToDoRepository myRepository = new ToDoRepository();
ToDo myTestToDo = myRepository.Create();
myTestToDo.Title = "Test1";
myRepository.Delete(myTestToDo);
Assert.AreEqual(0, myRepository.GetAll().Count);
}
