public void CreateNewTaskForAnroid(string description, string userid, string assigntoId, string comment)
{
string descritption = description;
Guid idtoassign = Guid.Empty;
idtoassign = Guid.Parse(assigntoId);
Domain.Myfashion.Domain.Tasks objTask = new Domain.Myfashion.Domain.Tasks();
TaskRepository objTaskRepo = new TaskRepository();
objTask.AssignDate = DateTime.Now.ToString("yyyy-MM-dd H:mm:ss").ToString();
objTask.AssignTaskTo = idtoassign;
objTask.TaskStatus = false;
objTask.TaskMessage = descritption;
objTask.UserId = Guid.Parse(userid);
Guid taskid = Guid.NewGuid();
objTask.Id = taskid;
objTaskRepo.addTask(objTask);
/////////////////
string Comment = comment;
if (!string.IsNullOrEmpty(comment))
{
string curdate = DateTime.Now.ToString("yyyy-MM-dd H:mm:ss").ToString();
Domain.Myfashion.Domain.TaskComment objcmt = new Domain.Myfashion.Domain.TaskComment();
TaskCommentRepository objcmtRepo = new TaskCommentRepository();
objcmt.Comment = comment;
objcmt.CommentDate = DateTime.Now;
objcmt.EntryDate = DateTime.Now;
objcmt.Id = Guid.NewGuid();
objcmt.TaskId = objTask.Id;
objcmt.UserId = Guid.Parse(userid);
objcmtRepo.addTaskComment(objcmt);
}
}
public void Init()
{
_taskRepository = Substitute.For<TaskRepository>();
_projectRepository = Substitute.For<IProjectRepository>();
_console = Substitute.For<IConsole>();
_addTaskCommand = new AddTaskCommand(_console, _taskRepository, _projectRepository, "secrets Eat more donuts.");
}
public void Init()
{
_taskRepository = new TaskRepository();
_console = new RealConsole();
_projectRepository = new ProjectRepository();
_taskCommandFactory = new TaskCommandFactory(_console, _projectRepository, _taskRepository);
}
public static void Main(string[] args)
{
var console = new RealConsole();
var projectRepository = new ProjectRepository();
var taskRepository = new TaskRepository();
var taskList = new TaskList(console, projectRepository, taskRepository);
taskList.Run();
}
public void Init()
{
_fakeConsole = Substitute.For<IConsole>();
_project = new Project("secrets");
_task = new Task("test", _project);
_taskRepository = new TaskRepository();
_taskRepository.Add(_task);
}
public TaskNodeFormModel(int typeid, TaskRepository taskRepositoryrepository, RoleRepository roleRepository)
{
WbsTypeId = typeid;
Repository = taskRepositoryrepository;
AvailableRoles = roleRepository.FindAll().ToList();
AvailableNodes = Repository.FindAll().Where(x => x.WbsTypeId == WbsTypeId).ToList();
Stages = StageRepository.FindStages().ToList();
}
public CourseDatabase()
{
Context = new DataContext();
Tasks = new TaskRepository(Context);
Users = new UserRepository(Context);
Tags = new TagsRepository(Context);
Answers = new AnswerRepository(Context);
Search = new SearchRepository();
}
public TaskCommandFactory(
IConsole console,
ProjectRepository projectRepository,
TaskRepository taskRepository)
{
_console = console;
_projectRepository = projectRepository;
_taskRepository = taskRepository;
}
public Task CreateTask(TaskRequest Task)
{
var entityToInsert = new Task()
{
};
MergeTask(entityToInsert, Task);
TaskRepository.Insert(entityToInsert);
return(entityToInsert);
}
public async Task Handle(PreviewImageAssignedEvent notification, CancellationToken cancellationToken)
{
using (var connection = this._dbConnectionFactory.OpenConnection())
{
var taskRepository = new TaskRepository();
var taskId = notification.AggregateId;
await taskRepository.ChangePreviewImageAsync(connection, taskId, notification.FileId);
}
}
// GET: Employee/Details/5
public ActionResult Details(int id)
{
EmployeeRepository employeeRepository = new EmployeeRepository();
TaskRepository taskRepository = new TaskRepository();
ViewModels.Employee.Details model = new ViewModels.Employee.Details();
model.employee = employeeRepository.GetById(id);
model.tasks = taskRepository.GetTasksForEmployee(id);
return(View(model));
}
private bool AddTask(Task task)
{
using (ProjectManagerContext _dbContext = CreateContext())
{
ITaskRepository _repo = new TaskRepository(_dbContext);
var controller = new TaskController(_repo);
var result = controller.AddTask(task);
return(result);
}
}
public void Init()
{
_taskRepository = new TaskRepository();
var project = new Project("secrets");
var task = new Task("Eat more donuts.", project) {Id = 1L};
_taskRepository.Add(task);
_fakeConsole = Substitute.For<IConsole>();
_showCommand = new ShowCommand(_fakeConsole, _taskRepository);
}
public void AddTask_name1_name1Out()
{
task t = new task();
TaskRepository _t = new TaskRepository();
string name = "Task1";
t.name = name;
Assert.AreEqual(t.name, name);
}
public async Task UpdateTaskProgress(int taskId)
{
byte[] buffer = new byte[268435456];
var server = await WorkerRepository.GetServerByAssignedTaskId(taskId);
_connectionService.SendBytes(Bytes.type["progress_request"], server.IpAddress, server.Port);
_connectionService.ReceiveBytes(ref buffer, server.IpAddress, server.Port);
buffer = buffer.RemovePrefix();
await TaskRepository.UpdateTaskPercent(taskId, buffer[0]);
}
public void Delete_Task_Test()
{
var service = new TaskService(Mapper);
var result = service.DeleteTask(new DeleteTaskRequest(), UnitOfWork);
EmployeeRepository.Verify(r => r.RemoveItem(It.IsAny <Employee>()), Times.Never);
ProjectRepository.Verify(r => r.RemoveItem(It.IsAny <Project>()), Times.Never);
TaskRepository.Verify(r => r.RemoveItem(It.IsAny <Task>()), Times.Once);
}
public void AddTask(Task newTask)
{
newTask.ManagerID = newTask.Manager.ID;
newTask.CreatorID = newTask.Creator.ID;
newTask.ExecutorID = newTask.Executor.ID;
newTask.Manager = null;
newTask.Executor = null;
newTask.Creator = null;
TaskRepository.AddItem(newTask);
}
private async Task RemoveTasksByProductId(Guid productId)
{
// Remove all the current tasks associated with the Product
var tasks = TaskRepository.Get().Where(t => t.ProductId == productId);
foreach (var task in tasks)
{
await TaskRepository.DeleteAsync(task.Id);
}
}
public void NewTask(string title)
{
var repo = new TaskRepository(connectionString);
var task = new UserTask {
Title = title, Completed = false
};
repo.AddTask(task);
RenderTasks();
}
public ProcessorTasks(Repository <TaskEntity> pgTasks,
TaskRepository mongoTasks,
bool dryRun,
Action <int> progressNotifier = null)
{
_pgTasks = pgTasks;
_mongoTasks = mongoTasks;
_dryRun = dryRun;
_progressNotifier = progressNotifier;
}
public void DeliteTask(List<TaskJson> TaskList)
{
TaskRepository _TaskRepository = new TaskRepository();
TaskTranslator _TaskTranslator = new TaskTranslator();
foreach (TaskJson Taskjson in TaskList)
{
if(Taskjson.ID!=null)
_TaskRepository.ChekhDelitByID(Guid.Parse(Taskjson.ID));
}
}
public ReportsController(IUnitOfWork unitOfWork)
: base(unitOfWork)
{
_categoryRepostitory = new CategoryRepostitory(unitOfWork);
_tasklogRepository = new TasklogRepository(unitOfWork);
_montReportDocRepository = new MontReportDocRepository(unitOfWork);
_stateCategoryRepostitory = new StateCategoryRepostitory(unitOfWork);
_tasknodeRep = new TaskRepository(unitOfWork);
_fileStore = new DiskFileStore();
}
public void SetUp()
{
var options = new DbContextOptionsBuilder <SampleContext>()
.UseInMemoryDatabase($"{Guid.NewGuid()}")
.Options;
Context = new SampleContext(options, new NullLogger <SampleContext>());
new DevSeed().Seed(Context);
Repo = new TaskRepository(Context);
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
MainWindow window = new MainWindow();
var repository = new TaskRepository(new InMemoryTaskStore());
var viewModel = new TaskListViewModel(repository);
window.DataContext = viewModel;
window.Show();
}
public AppSettingController(IUnitOfWork unitOfWork)
: base(unitOfWork)
{
_departRepository= new DepartRepository(unitOfWork);
_roleRepository = new RoleRepository(unitOfWork);
_wbsTaskRepository = new WBSTaskRepository(unitOfWork);
_taskRepository = new TaskRepository(unitOfWork);
_categoryRepostitory = new CategoryRepostitory(unitOfWork);
_stateCategoryRepostitory = new StateCategoryRepostitory(unitOfWork);
_nodeDocTypeRepository = new NodeDocTypeRepository(unitOfWork);
}
public SetDoneCommand(
IConsole console,
TaskRepository taskRepository,
string remainingCommandLine,
bool done)
{
_console = console;
_taskRepository = taskRepository;
_remainingCommandLine = remainingCommandLine;
_done = done;
}
public void StateNameManager_stat1_equalstat1()
{
ManagerRepository _m = new ManagerRepository();
ComandRepository _c = new ComandRepository();
TaskRepository _t = new TaskRepository();
int id = 0;
string state2 = "";
string state1 = _t.GetObject(Convert.ToInt32(_c.GetObject(Convert.ToInt32(_m.GetObject(id).comandId)).taskID)).name;
Assert.AreEqual(state1, state2);
}
}//получаем меняем состояние задачи у менеджера с записью правок и самого состояния
public void ChangeDeadline(int id, string edit, int dead)
{
ManagerRepository _m = new ManagerRepository();
ComandRepository _c = new ComandRepository();
TaskRepository _t = new TaskRepository();
_t.GetObject(Convert.ToInt32(_c.GetObject(Convert.ToInt32(_m.GetObject(id).comandId)).taskID)).date_end = dead;
_t.GetObject(Convert.ToInt32(_c.GetObject(Convert.ToInt32(_m.GetObject(id).comandId)).taskID)).checkList = edit;
_t.Update(_t.GetObject(Convert.ToInt32(_c.GetObject(Convert.ToInt32(_m.GetObject(id).comandId)).taskID)));
_t.Save();
}
public async Task GetAll_Returns_CorrectType()
{
// Arrange
var repository = new TaskRepository(dbContext);
// Act
var results = await repository.GetAll();
// Assert
Assert.IsAssignableFrom <IEnumerable <Model.Task> >(results);
}
public async Task GetAll_Returns_AllTasks()
{
// Arrange
var repository = new TaskRepository(dbContext);
// Act
var results = await repository.GetAll();
// Assert
Assert.Equal(4, results.Count());
}
public TaskManager(
TaskRepository taskRepository,
TaskPool taskPool,
JobLauncher jobLauncher,
IConfigurationProvider configuration)
{
_taskRepository = taskRepository;
_taskPool = taskPool;
_jobLauncher = jobLauncher;
_configuration = configuration;
}
//
// GET: /Task/Details/5
public ActionResult Details(int id)
{
var taskRepo = new TaskRepository();
var workRepo = new WorkLoadRepository();
var task = taskRepo.GetTaskWithRelevantData(id);
task.TotalWorkHours = workRepo.GetTotalWorkedHoursForTask(id);
return(View(task));
}
public async void CreateScheduleTest()
{
var taskRepository = new TaskRepository();
var habitRepository = new HabitRepository();
var service = new ScheduleService(taskRepository, habitRepository);
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
await service.CreateSchedule("eda1df41-a346-48dc-81ea-1f3288fcd58a", "d6a79a07-8f98-40fd-b1c2-d6269b3d6918");
Assert.True(true);
}
public AddTaskCommand(
IConsole console,
TaskRepository taskRepository,
IProjectRepository projectRepository,
string remainingCommandLine)
{
_taskRepository = taskRepository;
_projectRepository = projectRepository;
_remainingCommandLine = remainingCommandLine;
_console = console;
}
public static Task AddTask(string name)
{
var repo = new TaskRepository();
var task = new Task()
{
Name = name
};
repo.Add(task);
return(task);
}
public HttpResponseMessage Get()
{
try
{
return(Request.CreateResponse(HttpStatusCode.OK, TaskRepository.ReadAll()));
}
catch (Exception exc)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Generic error happened."));
}
}
public IActionResult GetEnv()
{
var list = TaskRepository.GetEnv();
list.ForEach(x =>
{
x.isSet = true;
x._temporary = false;
});
return(Ok(list));
}
public async Task Get_Returns_CorrectType()
{
// Arrange
var repository = new TaskRepository(dbContext);
// Act
var result = await repository.Get(1);
// Assert
Assert.IsAssignableFrom <Model.Task>(result);
}
/// <summary>
/// Obsluguje klikniecie danego zadania na liscie
/// Otwiera formularz z wybranym zadaniem
/// </summary>
/// <param name="sender">Obiekt wywołujący zdarzenie</param>
/// <param name="e">Akrumenty eventu</param>
private void taskListView_Click(object sender, EventArgs e)
{
var selected = taskListView.SelectedItems[0].SubItems[0];
int id = int.Parse(selected.Text);
Model.Task task = TaskRepository.getById(id);
TaskForm taskForm = new TaskForm(this, task);
taskForm.Show(this);
}
public dynamic Put(TaskDTO objtaskdto)
{
TaskDTO Oldtask = (TaskDTO)TaskRepository.GetTicketDetails(objtaskdto.ID).Response;
Mst_Task objtask = new Mst_Task {
ID = objtaskdto.ID, CreatedBy = objtaskdto.CreatedBy, UpdatedBy = objtaskdto.UpdatedBy, Title = objtaskdto.Title, Task_Status = objtaskdto.Task_Status, Description = objtaskdto.Description, DueDate = objtaskdto.DueDate, PriorityID = objtaskdto.PriorityID, TypeID = objtaskdto.TypeID, RefereedTo = objtaskdto.RefereedTo, AssignedTo = objtaskdto.AssignedTo, AssigndedDate = objtaskdto.AssigndedDate, ProjectID = objtaskdto.ProjectID
};
CustomResponse res = TaskRepository.UpdateTicket(objtask);
List <string> ObjToAddresses = new List <string>();
List <string> ObjFilteredToAddresses = new List <string>();
if (res.Status == CustomResponseStatus.Successful)
{
ObjToAddresses.Add(objtaskdto.CreatedBy);
ObjToAddresses.Add(objtaskdto.RefereedTo);
ObjToAddresses.Add(objtaskdto.AssignedTo);
// Get All Stackholders related to project
ObjToAddresses.AddRange(ProjectRepository.GetProjectUsers(objtaskdto.ProjectID));
ObjFilteredToAddresses = ObjToAddresses.Distinct().ToList();
ObjFilteredToAddresses = UserRepository.GetEmailAddressesByUserIds(ObjFilteredToAddresses);
StringBuilder sb = new StringBuilder();
sb.Append("<table>");
sb.Append("<tr><td><center><b> Updated Ticket Infromation</b></center> <td></tr>");
sb.Append("<tr><td><center> Project Name </center> <td> <td><center>" + objtaskdto.ProjectID + " </center> <td></tr>");
sb.Append("<tr><td><center> Ticket ID </center> <td> <td><center>" + objtaskdto.ID + " </center> <td></tr>");
sb.Append("<tr><td><center> Ticket Titile </center> <td> <td><center>" + objtaskdto.Title + " </center> <td></tr>");
sb.Append("<tr><td><center> Ticket Description </center> <td> <td><center>" + objtaskdto.Description + " </center> <td></tr>");
sb.Append("<tr><td><center> Ticket Start Date </center> <td> <td><center>" + objtaskdto.AssigndedDate + " </center> <td></tr>");
sb.Append("<tr><td><center> Ticket Due Date </center> <td> <td><center>" + objtaskdto.DueDate + " </center> <td></tr>");
if (objtaskdto.PriorityID != Oldtask.PriorityID)
{
sb.Append("<tr><td><center> New Priority </center> <td> <td><center>" + GenericRepository.GetPrioritynameByPid(objtaskdto.PriorityID) + " </center> <td></tr>");
}
if (objtaskdto.Task_Status != Oldtask.Task_Status)
{
sb.Append("<tr><td><center> New Task Status </center> <td> <td><center>" + GenericRepository.GetTaskStausByPid(objtaskdto.Task_Status) + " </center> <td></tr>");
}
if (objtaskdto.TaskTypeName != Oldtask.TaskTypeName)
{
sb.Append("<tr><td><center> New Task Type </center> <td> <td><center>" + GenericRepository.GetTasknameByPid(objtaskdto.TypeID) + " </center> <td></tr>");
}
sb.Append("</table>");
string subject = "Tech Support - Ticket Updtaes Information";
foreach (var toMail in ObjFilteredToAddresses)
{
MailSender.TaskStatusCreate_UpdationMail(UserReportRepository.GetFnameByEmail(toMail), subject, sb.ToString(), toMail);
}
}
return(res);
}
public OverviewModel()
{
BackendlessUser user = Backendless.UserService.CurrentUser;
TaskRepository taskRepo = new TaskRepository();
ListOfAllTasks = taskRepo.GetListOfObjectsFromTable("TaskName LIKE '%'");
ListOfUserTasks = new List <TaskModel>();
foreach (var task in ListOfAllTasks)
{
TotalNumberOfTasks++;
if (task.TaskStatus == "Otwarte")
{
NumberOfTasksWithStatusOpen++;
}
if (task.TaskStatus == "W Trakcie")
{
NumberOfTasksWithStatusInProgress++;
}
if (task.TaskStatus == "Przegląd Kodu")
{
NumberOfTasksWithStatusCodeReview++;
}
if (task.TaskStatus == "Zakończone")
{
NumberOfTasksWithStatusDone++;
}
if (task.TaskPriority == "Krytyczny")
{
NumberOfTasksWithPriorityCritical++;
}
if (task.TaskPriority == "Bardzo Wysoki")
{
NumberOfTasksWithPriorityVeryHigh++;
}
if (task.TaskPriority == "Wysoki")
{
NumberOfTasksWithPriorityHigh++;
}
if (task.TaskPriority == "Średni")
{
NumberOfTasksWithPriorityMedium++;
}
if (task.TaskPriority == "Niski")
{
NumberOfTasksWithPriorityLow++;
}
if (user != null && task.TaskAssignedToUser == (user.Properties["name"] + " " + user.Properties["surname"]))
{
NumberOfTasksAssignedToUser++;
ListOfUserTasks.Add(task);
}
}
}
public List <string> ShowEdits(int id)
{
List <string> tmp = new List <string>();
ManagerRepository _m = new ManagerRepository();
ComandRepository _c = new ComandRepository();
TaskRepository _t = new TaskRepository();
tmp.Add(_t.GetObject(Convert.ToInt32(_c.GetObject(Convert.ToInt32(_m.GetObject(id).comandId)).taskID)).checkList);
return(tmp);
}//получаем в список правки
public ComfortDevUnitOfWork(ComfortDevContext db)
{
this.db = db;
CourseTasks = new CourseTaskRepository(db);
Tasks = new TaskRepository(db);
TestAnswers = new TestAnswerRepository(db);
TestQuestions = new TestQuestionRepository(db);
Topics = new TopicRepository(db);
Users = new UserRepository(db);
UserCourses = new UserCourseRepository(db);
}
public void CanStartSaveGetAndStop()
{
var taskRepository = new TaskRepository() { Configuration = new CoreConfiguration(".",".") };
var task = new Task("do stuff");
task.Start();
taskRepository.CreateTask(task);
Thread.Sleep(TimeSpan.FromSeconds(1)); // TODO: remove this sleep
var loadedTask = taskRepository.FromFileName(task.FileName);
loadedTask.Stop();
Assert.Equal(1, loadedTask.Durations.Count);
}
static void Main(string[] args)
{
//TODO: unit tests assembly, maybe based on nUnit ?
ITaskRepository taskRepository = new TaskRepository(new TaskManContext());
var tasks = taskRepository.GetAll();
foreach (var task in tasks)
{
Console.WriteLine("Title: {0}", task.Title);
Console.WriteLine("Author: {0}", task.Author.Login);
Console.WriteLine("-------------------------------");
}
Console.ReadLine();
}
public TaskNodeEditForm(int id, int typeid, TaskRepository repository, RoleRepository roleRepository)
: base(typeid, repository, roleRepository)
{
var tasknode = Repository.Find(id);
TaskNodeId = tasknode.TaskNodeId;
WbsTypeId = tasknode.WbsTypeId;
StageValue = tasknode.StageValue;
WBSCode = tasknode.WBSCode;
TaskName = tasknode.TaskName;
DayToCost = tasknode.DayToCost;
CountWorkDay = tasknode.CountWorkDay;
StageEnd = tasknode.StageEnd;
RoleId = tasknode.RoleId;
NodeFlag = tasknode.NodeFlag;
DependOn = tasknode.DependOnNodes.ToList();
AvailableNodes = Repository.FindAll().Where(x => x.WbsTypeId.Equals(WbsTypeId) && x.StageValue <= StageValue).ToList();
}
public TaskRepositoryTests()
{
_configuration = new Configuration();
_configuration.Configure();
_configuration.AddAssembly(typeof(Project).Assembly);
_sessionFactory = _configuration.BuildSessionFactory();
_projectRepository = new ProjectRepository {SessionFactory = _sessionFactory};
_taskRepository = new TaskRepository {SessionFactory = _sessionFactory};
CurrentSessionContext.Bind(_sessionFactory.OpenSession());
new SchemaExport(_configuration).Execute(false, true, false, false);
CreateTestData();
}
public void RepositoryWorks()
{
var taskRepository = new TaskRepository() { Configuration = new CoreConfiguration(".", ".") };
var task = new Task("do stuff");
task.Start();
task.Stop();
task.Start();
task.Stop();
taskRepository.CreateTask(task);
var loadedTask = taskRepository.FromFileName(task.FileName);
Assert.Equal(task.Durations.Count, loadedTask.Durations.Count);
Assert.Equal(task.Name, loadedTask.Name);
}
public OctopusRepository(IOctopusClient client)
{
this.Client = client;
Feeds = new FeedRepository(client);
Backups = new BackupRepository(client);
Machines = new MachineRepository(client);
MachineRoles = new MachineRoleRepository(client);
MachinePolicies = new MachinePolicyRepository(client);
Subscriptions = new SubscriptionRepository(client);
Environments = new EnvironmentRepository(client);
Events = new EventRepository(client);
FeaturesConfiguration = new FeaturesConfigurationRepository(client);
ProjectGroups = new ProjectGroupRepository(client);
Projects = new ProjectRepository(client);
Proxies = new ProxyRepository(client);
Tasks = new TaskRepository(client);
Users = new UserRepository(client);
VariableSets = new VariableSetRepository(client);
LibraryVariableSets = new LibraryVariableSetRepository(client);
DeploymentProcesses = new DeploymentProcessRepository(client);
Releases = new ReleaseRepository(client);
Deployments = new DeploymentRepository(client);
Certificates = new CertificateRepository(client);
Dashboards = new DashboardRepository(client);
DashboardConfigurations = new DashboardConfigurationRepository(client);
Artifacts = new ArtifactRepository(client);
Interruptions = new InterruptionRepository(client);
ServerStatus = new ServerStatusRepository(client);
UserRoles = new UserRolesRepository(client);
Teams = new TeamsRepository(client);
RetentionPolicies = new RetentionPolicyRepository(client);
Accounts = new AccountRepository(client);
Defects = new DefectsRepository(client);
Lifecycles = new LifecyclesRepository(client);
OctopusServerNodes = new OctopusServerNodeRepository(client);
Channels = new ChannelRepository(client);
ProjectTriggers = new ProjectTriggerRepository(client);
Schedulers = new SchedulerRepository(client);
Tenants = new TenantRepository(client);
TagSets = new TagSetRepository(client);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client);
ActionTemplates = new ActionTemplateRepository(client);
CommunityActionTemplates = new CommunityActionTemplateRepository(client);
}
public void CanUpdateTasks()
{
Task task = new Task { Description = "kuvaus", Status = "ToDo" };
taskRepository.Save(task);
session.Dispose();
session = documentStore.OpenSession();
taskRepository=new TaskRepository(session);
var updateTask = taskRepository.Find().First();
updateTask.Status = "Done";
taskRepository.Update(updateTask);
session.Dispose();
session = documentStore.OpenSession();
taskRepository = new TaskRepository(session);
var result = taskRepository.Find().First();
Assert.That(result.Status,Is.EqualTo("Done"));
}
public RepositoryViewModel(TaskRepository repository, IDialogServiceFactory fileDialogServiceFactory, String filename)
{
if (null == repository)
throw new ArgumentNullException("repository");
if (null == fileDialogServiceFactory)
throw new ArgumentNullException("fileDialogService");
_dialog = fileDialogServiceFactory.CreateService();
_repository = repository;
_filename = filename;
_workspaces = new WorkspaceCollectionViewModel<WorkspaceViewModel>();
_tree = new WorkspaceCollectionViewModel<CollectionTreeViewModel>(
_repository.Select(x => new CollectionTreeViewModel(x, _repository, _dialog)));
_tree.PropertyChanged += this.OnChildCollectionPropertyChanged;
_tree.RequestOpen += this.OnWorkspaceRequestOpen;
_workspaces.PropertyChanged += this.OnChildCollectionPropertyChanged;
_workspaces.RequestOpen += this.OnWorkspaceRequestOpen;
_workspaces.RequestClose += this.OnWorkspaceRequestClose;
_repository.RepositoryChanged += this.OnRepositoryChanged;
this.IsSaved = true;
}
public OrdersController(CategoryRepository categoryRepository,
UserRepository userRepository, SubcategoryRepository subcategoryRepository,
OrdersRepository ordersRepository, AssetRepository assetRepository, TaskRepository taskRepository,
ReviewRepository reviewRepository, UserService userService,
UserResponseHistoryRepository userResponseHistoryRepository,
ViewCounterService viewCounterService,
BillingService billingService, GigbucketDbContext dbContext)
{
_categoryRepository = categoryRepository;
_userRepository = userRepository;
_subcategoryRepository = subcategoryRepository;
_ordersRepository = ordersRepository;
_assetRepository = assetRepository;
_taskRepository = taskRepository;
_reviewRepository = reviewRepository;
_userService = userService;
_userResponseHistoryRepository = userResponseHistoryRepository;
_viewCounterService = viewCounterService;
_billingService = billingService;
_dbContext = dbContext;
}
public void CanFindAll()
{
var story = new Story();
story.Title = "My New story";
story.Description = "loooooooo";
story.Status = StoryStatus.Started;
story.CreatedBy = m_database.Users.All().ToList<dynamic>()[0].Id;
story.ProjectId = m_database.Projects.All().ToList<dynamic>()[0].Id;
DatabaseOperationResponse response = m_repository.Save(story);
Assert.IsTrue(response.HasSucceeded);
var repository = new TaskRepository(DatabaseHelper.GetConnectionString());
var task = new Task();
task.Description = "Im a task";
task.Assignees = "Dude1, Dude2";
task.IsCompleted = true;
task.StoryId = m_database.Stories.All().ToList<dynamic>()[0].Id;
response = repository.Save(task);
Assert.IsTrue(response.HasSucceeded, response.Description);
var task2 = new Task();
task2.Description = "Yes I am a taks";
task2.Assignees = "Dude1, Dude2";
task2.IsCompleted = true;
task2.StoryId = m_database.Stories.All().ToList<dynamic>()[0].Id;
response = repository.Save(task2);
Assert.IsTrue(response.HasSucceeded, response.Description);
var stories = m_repository.FindAll();
Assert.AreEqual(1, stories.Count);
Assert.AreEqual(2, stories[0].Tasks.Count);
Assert.NotNull(stories[0].Project);
Assert.AreEqual(story.ProjectId, stories[0].Project.Id);
}
// This constructor is not used by the MVC framework but is instead provided for ease
// of unit testing this type. See the comments at the end of this file for more
// information.
public AccountController(IFormsAuthentication formsAuth, IMembershipService membershipService, TaskRepository taskRepository)
{
this.FormsAuth = formsAuth ?? new FormsAuthenticationService();
this.MembershipService = membershipService ?? new AccountMembershipService();
this.TaskRepository = taskRepository ?? new TaskRepository();
}
public string GetAllTeamTask(string userid, string groupid)
{
TaskRepository taskrepo = new TaskRepository();
ArrayList TaskData = new ArrayList();
TaskData = taskrepo.getAllTasksOfUser(Guid.Parse(userid), Guid.Parse(groupid));
List<Domain.Myfashion.Domain.Tasks> taskdata = new List<Domain.Myfashion.Domain.Tasks>();
foreach (Domain.Myfashion.Domain.Tasks item in TaskData)
{
taskdata.Add(item);
}
return new JavaScriptSerializer().Serialize(TaskData);
}
public string GetAllTasks(string custid)
{
ArrayList taskdata = new ArrayList();
TaskCommentRepository objTaskCmtRepo = new TaskCommentRepository();
TaskRepository taskrepo = new TaskRepository();
taskdata = taskrepo.getAllTasksOfUser(Guid.Parse(custid));
return new JavaScriptSerializer().Serialize(taskdata);
}
public TodoController(TaskRepository repository)
{
this.repository = repository ?? new TaskRepository();
}
void OnRepositoryChanged(TaskRepository repository, RepositoryChangedEventArgs e)
{
if (!e.Removed)
_tree.Add(new CollectionTreeViewModel(e.Element, _repository, _dialog));
}
public void Init()
{
m_repository = new TaskRepository(DatabaseHelper.GetConnectionString());
m_database = Database.OpenConnection(DatabaseHelper.GetConnectionString());
m_database.Users.Insert(UserName: "******", FirstName: "Some", LastName: "Dude", APIKey: "yuiu-998",
Email: "*****@*****.**", Privileges: 2, Password:"******");
m_database.Projects.Insert(Title: "wololo", Description: "blah");
dynamic story = new ExpandoObject();
story.Title = "My New story";
story.Description = "loooooooo";
story.Status = 3;
story.CreatedBy = m_database.Users.All().ToList<dynamic>()[0].Id;
story.CreatedOn = DateTime.UtcNow;
story.LastEditedOn = DateTime.UtcNow;
story.ProjectId = m_database.Projects.All().ToList<dynamic>()[0].Id;
m_database.Stories.Insert(story);
}
public RepositoryViewModel(TaskRepository repository, IDialogServiceFactory fileDialogServiceFactory)
: this(repository, fileDialogServiceFactory, null)
{
}
