public async Task DeleteToDoAsyncServiceTest()
{
// arrange
var toDos = GetTestData();
var deletedToDo = new ToDoViewModel
{
Id = 1,
ToDoItem = "Get a new bike"
};
// act
var mockSet = SetupMockSetAsync(new Mock <DbSet <ToDo> >(), toDos);
var mockContext = new Mock <AndresToDoListContext>();
mockContext.Setup(s => s.ToDos).Returns(mockSet.Object);
var toDoService = new ToDoService(mockContext.Object);
await toDoService.DeleteToDoAsync(deletedToDo.Id);
var count = mockContext.Object.ToDos.AsEnumerable().ToList();
// assert
Assert.IsTrue(mockContext.Object.ToDos.Any());
}
public async Task <IActionResult> GetToDoAsync(string userId, string todoId)
{
var UserIdfromTokken = HttpContext.User.FindFirst(p => p.Type == "sub").Value;
if (UserIdfromTokken == null || userId != UserIdfromTokken)
{
var error = ServiceErrorResponses.AuthIsNotConfirmed("Unauthorized request");
}
var todoServ = new ToDoService(UserIdfromTokken);
if (!int.TryParse(todoId, out var ToDoIdCheck))
{
var error = ServiceErrorResponses.ToDoNotFound(todoId);
return(this.NotFound(error));
}
var todoIdGet = todoServ.Get(ToDoIdCheck);
if (todoIdGet == null)
{
var error = ServiceErrorResponses.ToDoNotFound(todoId);
return(this.NotFound(error));
}
return(this.Ok(todoIdGet));
}
public async void OnMarkComplete(object sender, EventArgs e)
{
viewModel.VisibleLoad = true;
viewModel.LoadingMessage = "";
try
{
item.WorkPercentComplete = viewModel.WorkPercentComplete = 100;
var response = await ToDoService.SaveTodo(item);
if (!response.HasErrors)
{
//btnMarkAsComplete.IsVisible = false;
//txtStatus.Text = viewModel.WorkStatus = "Done";
Common.Instance.ShowToastMessage("Success mark as completed ToDo!", DoubleResources.SuccessSnackBar);
}
else
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
}
catch (Exception ex)
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
viewModel.LoadingMessage = "Success";
viewModel.VisibleLoad = false;
}
public async Task UpdateToDoAsyncServiceTest()
{
// arrange
var toDos = GetTestData();
var updatedToDo = new ToDoViewModel
{
Id = 1,
ToDoItem = "Get a new car"
};
// act
var mockContext = new Mock <AndresToDoListContext>();
var mockSet = SetupMockSetAsync(new Mock <DbSet <ToDo> >(), toDos);
mockContext.Setup(s => s.ToDos).Returns(mockSet.Object);
var toDoService = new ToDoService(mockContext.Object);
await toDoService.UpdateToDoAsync(updatedToDo);
// assert
Assert.IsTrue((await mockContext.Object.ToDos.
SingleOrDefaultAsync(x => x.Id == updatedToDo.Id))?.ToDoItem == updatedToDo.ToDoItem);
}
public void GetAllTest()
{
ToDoService toDoService = new ToDoService();
Response response = toDoService.GetAll();
Assert.IsNotNull(response.Data);
}
private ToDoService CreateToDoService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new ToDoService(userId);
return(service);
}
public ToDoesController(ToDoContext context)
{
this.context = context;
// **CORE**
// a L'initialistaiton du controlleur il va créer la Base service et donner l'accès à la BDD en utilisant le constructeur
todoService = new ToDoService(context);
}
async Task DeleteGroupAsync(ToDoGroupDto group)
{
if (await PageDialogService.DisplayAlertAsync(Strings.DeleteGroup, string.Format(Strings.DeleteGroupForever, group.Title), Strings.Delete, Strings.Cancel))
{
await ToDoService.DeleteGroup(group, CancellationToken.None);
}
}
public string showList()
{
//if ((bool)data["isAuth"] == false)
// return "<script>window.location = 'http://127.0.0.1:5600/user/login'</script>";
//else
//{
StringBuilder strBuilder = new StringBuilder();
strBuilder.Append("<ol>");
int count = 0;
var userList = new ToDoService();
foreach (var elem in userList.GetUserToDoList())
{
strBuilder.Append($"<li>{elem.ItemName}<form method='POST' action='http://127.0.0.1:5600/toDo/changeState'> <input type='checkbox' name='check' {elem.ItemState}> <input type='hidden' name='id' value={count}> <input type='submit'> </form> </li>");
count++;
}
strBuilder.Append("</ol>");
strBuilder.Append($"<form method='POST' action='http://127.0.0.1:5600/toDo/addToDo'> <label>To do: </label> <input type='text' name='toDoName' required> <input type='submit' value='Add'> </form>");
strBuilder.Append("<form method='GET' action='http://127.0.0.1:5600/user/login'> <input type='submit' value='Log Out'> </form>");
return(strBuilder.ToString());
//}
}
public async Task UpdateToDoAsyncControllerTest()
{
// arrange
var toDos = GetTestData();
var mockToDoSet = SetupMockSetAsync(new Mock <DbSet <ToDo> >(), toDos);
var mockContext = new Mock <AndresToDoListContext>();
mockContext.Setup(s => s.ToDos).Returns(mockToDoSet.Object);
var toDoToUpdate = new ToDoViewModel
{
Id = 1,
ToDoItem = "Find my lost friend"
};
// act
var toDoService = new ToDoService(mockContext.Object);
var toDoController = new ToDoController(toDoService);
var controllerActionResult = await toDoController.UpdateToDo(toDoToUpdate);
// assert
Assert.IsInstanceOfType(controllerActionResult, typeof(OkNegotiatedContentResult <bool>));
}
public void DeleteAsync()
{
var toDoService = new ToDoService(_unitOfWork.Object);
var result = toDoService.DeleteTodo(_todoArray[0].ConvertObject());
Assert.IsTrue(result.Result);
}
public void TestAsyncList_userid2()
{
var toDoService = new ToDoService(_unitOfWork.Object);
var result = toDoService.GetList("userid2");
Assert.AreEqual(result.Result.Count, 2);
}
public void Setup()
{
_mapperMock = new Mock <IMapper>();
_repositoryMock = new Mock <IToDoItemsRepository>();
_loggerMock = new Mock <ILogger <ToDoService> >();
_service = new ToDoService(_repositoryMock.Object, _mapperMock.Object, _loggerMock.Object);
}
public void GetAllCompletedTest()
{
var service = new ToDoService(_httpClient);
var results = service.GetAllCompleted();
Assert.True(results.First().Completed);
}
public async Task DeleteById_CompletedToDosMustBeSoftDeleted()
{
// arrange
var moq = new Mock <IRepository <ToDo> >();
var completed = new ToDo {
IsCompleted = true
};
moq.Setup(r => r.GetById(It.IsAny <int>()))
.Returns(Task.FromResult(completed));
moq.Setup(r => r.Remove(It.IsAny <ToDo>()))
.Returns(Task.CompletedTask);
moq.Setup(r => r.Update(It.IsAny <ToDo>()))
.Returns(Task.CompletedTask);
var service = new ToDoService(moq.Object);
// act
var result = await service.DeleteById(1);
// assert
Assert.True(completed.IsDeleted);
moq.Verify(r => r.GetById(It.IsAny <int>()), Times.Once);
moq.Verify(r => r.Update(It.IsAny <ToDo>()), Times.Once);
moq.Verify(r => r.Remove(It.IsAny <ToDo>()), Times.Never);
Assert.Equal(completed, result);
}
static SyncService()
{
remoteService = new ToDoService();
db = new QueueDB();
delQueue = new Queue <ToDoItem>(db.Tasks.Where(t => t.IsDeleted));
addQueue = new Queue <ToDoItem>(db.Tasks.Where(t => !t.IsUploaded && !t.IsDeleted));
updateQueue = new Queue <ToDoItem>(db.Tasks.Where(t => t.IsChanged));
}
public string addToDo(string toDoName)
{
var toDoS = new ToDoService();
toDoS.addToDoItem(toDoName);
return($"<script>window.location = 'http://127.0.0.1:5600/toDo/showList'</script>");
//return $"<script>window.location = 'http://127.0.0.1:5600/toDo/showList?token={UserService.UserToken}'</script>";
}
public ToDoServiceTests()
{
_toDoRepositoryMock = new Mock <IToDoRepository>();
_mapperMock = new Mock <IMapper>();
_service = new ToDoService
(_toDoRepositoryMock.Object, _mapperMock.Object);
}
public void Execute()
{
BllTask result = repository.GetById(itemId);
ToDoService.UpdateItem(result);
actionRepository.Delete(actionId);
}
// GET: Task
public ActionResult Index()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new ToDoService(userId);
var model = service.GetToDos();
return(View(model));
}
public ActionResult GetDbAuth(string id)
{
return(new JsonResult()
{
Data = ToDoService.GetToDo(id),
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public void GetAllTest()
{
var service = new ToDoService(_httpClient);
var results = service.GetAll();
Assert.Equal(200, results.Count);
Assert.Equal("delectus aut autem", results.First().Title);
}
public void GetByIdTest()
{
int id = 1;
ToDoService toDoService = new ToDoService();
Response response = toDoService.GetById(id);
Assert.IsNotNull(response.Data);
}
public NewModel(ToDoService todoService, IConfiguration config, ILogger <NewModel> logger)
{
_todoService = todoService;
_config = config;
_logger = logger;
ReadOnly = _config.GetValue <bool>("Database:ReadOnly");
}
private async Task AddNewGroupAsync()
{
ToDoGroupDto group = await ToDoService.AddNewGroup(NewGroupName, CancellationToken.None);
ToDoService.ToDoGroups.Add(group);
ToDoService.ToDoGroups = new List <ToDoGroupDto>(ToDoService.ToDoGroups);
NewGroupName = string.Empty;
}
private static async Task DeleteToDoAsync()
{
Console.Write("Enter Id of the ToDo that you want Delete : ");
var id = Console.ReadLine();
await ToDoService.RemoveToDoAsync(id);
await ListAllToDosAsync();
}// + upp i main
private static async Task CreateToDoAsync() //skapa nån
{ // ska tilläga utskriv f. för de programm som har inte console
Console.Write("Enter a new activity : "); // fråga user
string activity = Console.ReadLine();
await ToDoService.AddToDoAsync(activity);
Console.WriteLine("Create new ToDo in Datebase");
}
public void GetIncompleteForUserTest()
{
var service = new ToDoService(_httpClient);
var results = service.GetIncompleteForUser(5);
Assert.Equal(8, results.Count);
Assert.Equal(5, results.First().UserId);
Assert.False(results.First().Completed);
}
public async override Task OnNavigatedToAsync(INavigationParameters parameters)
{
await base.OnNavigatedToAsync(parameters);
if (parameters.GetNavigationMode() == NavigationMode.New)
{
await ToDoService.LoadData(CancellationToken.None);
}
}
// ska tilläga utskriv f. för de programm som har inte console
private static async Task CreateToDoAsync() //skapa nån
{
Console.Write("Enter a new activity : "); // fråga user
string activity = Console.ReadLine();
await ToDoService.AddToDoAsync(activity);//
Console.WriteLine("Create new ToDo in Datebase");
}
private string Save(ToDoService.ToDoItemContract toDoItemContract)
{
// get the todo list items
ToDoService.ToDoServiceClient client = new ToDoService.ToDoServiceClient();
try
{
// save the new task
return client.SaveToDoItem(toDoItemContract);
}
catch (Exception ex)
{
client.Abort();
// TODO: Client side save error message
return "";
}
}
private string Save(ToDoService.ToDoItemContract toDoItemContract)
{
// get the todo list items
_client = new ToDoService.ToDoServiceClient();
try
{
// save the new task
return _client.SaveToDoItem(toDoItemContract);
}
catch (Exception ex)
{
_client.Abort();
// ANDREI: logged an exeption into ErrorLog folder
ErrorLog.Instance.WriteLog(ex);
return "";
}
}
protected Group(ToDoService.Group dalGroup)
: this()
{
_DalObject = dalGroup;
}
protected Todo(ToDoService.Todo dalTodo)
: this()
{
_DalObject = dalTodo;
}
