public override void TestFixtureTearDown()
{
base.TestFixtureTearDown();
ProjectService projectService = new ProjectService();
projectService.Delete(_project.ID);
}
/// <summary>
/// Handles the Load event of the Page control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void Page_Load(object sender, EventArgs e)
{
ProjectService service = new ProjectService();
dgProjects.DataSource = service.GetByUser(Global.LoggedInUser.ID);
dgProjects.DataBind();
}
/// <summary>
/// Constructs the Freshbooks API authentication and wrapper class
/// </summary>
/// <param name="accountName">The account name for which you are trying to access</param>
/// <param name="consumerKey">The developer's freshbooks account name</param>
/// <param name="oauthSecret">The developer's oauth-secret provided by freshbooks</param>
public FreshbooksApi(string accountName, string consumerKey, string oauthSecret)
{
_accountName = accountName;
_consumerKey = consumerKey;
_oauthSecret = oauthSecret ?? String.Empty;
_baseUri = new UriBuilder { Scheme = "https", Host = accountName + ".freshbooks.com" }.Uri;
_serviceUri = new Uri(_baseUri, "/api/2.1/xml-in");
Clear();
UserAgent = String.Format("{0}/{1} ({2})",
GetType().Name,
GetType().Assembly.GetName().Version.ToString(2),
GetType().Assembly.FullName);
Callback = new CallbackService(new ServiceProxy(this, "callback"));
Category = new CategoryService(new ServiceProxy(this, "category"));
Client = new ClientService(new ServiceProxy(this, "client"));
Estimate = new EstimateService(new ServiceProxy(this, "estimate"));
Expense = new ExpenseService(new ServiceProxy(this, "expense"));
Gateway = new GatewayService(new ServiceProxy(this, "gateway"));
Invoice = new InvoiceService(new ServiceProxy(this, "invoice"));
Item = new ItemService(new ServiceProxy(this, "item"));
Language = new LanguageService(new ServiceProxy(this, "language"));
Payment = new PaymentService(new ServiceProxy(this, "payment"));
Project = new ProjectService(new ServiceProxy(this, "project"));
Recurring = new RecurringService(new ServiceProxy(this, "recurring"));
System = new SystemService(new ServiceProxy(this, "system"));
Staff = new StaffService(new ServiceProxy(this, "staff"));
Task = new TaskService(new ServiceProxy(this, "task"));
Tax = new TaxService(new ServiceProxy(this, "tax"));
TimeEntry = new TimeEntryService(new ServiceProxy(this, "time_entry"));
}
public void GetByIdTest()
{
var modelContainer = new TimeTrackerContext();
var service = new ProjectService(modelContainer);
var project = service.GetById(2);
Assert.IsNotNull(project);
}
public void CreateServiceContext()
{
var services = new ServiceContext();
_projectService = new ProjectService();
services.Add(_projectService);
services.ServiceManager.StartServices();
}
public void ProjectService_GetAsync_ReturnsProjects()
{
//Arrange
var mockDbContextScopeFac = new Mock<IDbContextScopeFactory>();
var mockDbContextScope = new Mock<IDbContextReadOnlyScope>();
var mockEfDbContext = new Mock<EFDbContext>();
mockDbContextScopeFac.Setup(x => x.CreateReadOnly(DbContextScopeOption.JoinExisting)).Returns(mockDbContextScope.Object);
mockDbContextScope.Setup(x => x.DbContexts.Get<EFDbContext>()).Returns(mockEfDbContext.Object);
var dbEntry1 = new Project { Id = "dummyEntryId1", ProjectName = "Project1", ProjectAltName = "ProjectAlt1", IsActive_bl = false, ProjectCode = "CODE1" };
var dbEntry2 = new Project { Id = "dummyEntryId2", ProjectName = "Project2", ProjectAltName = "ProjectAlt2", IsActive_bl = true, ProjectCode = "CODE2" };
var dbEntries = (new List<Project> { dbEntry1, dbEntry2 }).AsQueryable();
var mockDbSet = new Mock<DbSet<Project>>();
mockDbSet.As<IDbAsyncEnumerable<Project>>().Setup(m => m.GetAsyncEnumerator()).Returns(new MockDbAsyncEnumerator<Project>(dbEntries.GetEnumerator()));
mockDbSet.As<IQueryable<Project>>().Setup(m => m.Provider).Returns(new MockDbAsyncQueryProvider<Project>(dbEntries.Provider));
mockDbSet.As<IQueryable<Project>>().Setup(m => m.Expression).Returns(dbEntries.Expression);
mockDbSet.As<IQueryable<Project>>().Setup(m => m.ElementType).Returns(dbEntries.ElementType);
mockDbSet.As<IQueryable<Project>>().Setup(m => m.GetEnumerator()).Returns(dbEntries.GetEnumerator());
mockDbSet.Setup(x => x.Include(It.IsAny<string>())).Returns(mockDbSet.Object);
mockEfDbContext.Setup(x => x.Projects).Returns(mockDbSet.Object);
var projectService = new ProjectService(mockDbContextScopeFac.Object, "dummyUserId");
//Act
var resultProjects = projectService.GetAsync().Result;
//Assert
Assert.IsTrue(resultProjects.Count == 1);
Assert.IsTrue(resultProjects[0].ProjectAltName.Contains("ProjectAlt2"));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="apiKey">The api key credential</param>
public WistiaDataClient(string apiKey)
{
if (string.IsNullOrWhiteSpace(apiKey)) throw new ArgumentNullException(apiKey);
Account = new AccountService(apiKey);
Projects = new ProjectService(apiKey);
Sharings = new SharingService(apiKey);
Media = new MediaService(apiKey);
}
/// <summary>
/// Initializes a new instance of the <see cref="DashboardController"/> class.
/// </summary>
/// <param name="reportService">The report service.</param>
/// <param name="releaseService">The release service.</param>
/// <param name="timesheetService">The timesheet service.</param>
/// <param name="projectComplianceReportService">The project compliance report service.</param>
/// <param name="projectService">The project service.</param>
public DashboardController(ReportService reportService, ReleaseService releaseService, TimesheetService timesheetService, ProjectComplianceReportService projectComplianceReportService, ProjectService projectService)
{
this.reportService = reportService;
this.releaseService = releaseService;
this.timesheetService = timesheetService;
this.projectComplianceReportService = projectComplianceReportService;
this.projectService = projectService;
this.AddBreadcrumbItem(Resources.Dashboard, string.Empty);
}
/*
* 关于项目的若干查询
*/
/// <summary>
/// 获取所有项目
/// </summary>
/// <returns></returns>
public JsonResult GetAllProject() {
ProjectService ps = new ProjectService();
List<Project> list = ps.FindAll();
Dictionary<string, string> dictionary = new Dictionary<string, string>();
for (int i = 0; i < list.Count; i++) {
dictionary.Add(list[i].ProjectName,(list[i].ID).ToString()+","+list[i].ProjectID);
}
return Json(dictionary);
}
public ProjectsController()
{
if (Projects == null) { Projects = new ProjectService(); }
if (Tasks == null) { Tasks = new MilestoneService(); }
if (Timeframes == null) { Timeframes = new TimeframesService(); }
if (Divisions == null) { Divisions = new DivisionService(); }
if (Tyypes == null) { Tyypes = new TypeService(); }
base.Initialize(new System.Web.Routing.RequestContext());
}
public override void Delete()
{
ProjectService target = new ProjectService();
Project project = (Project) CreateRecord();
Insert(project);
target.Delete(project.ID);
Assert.IsFalse(target.Exists(project.ID));
}
public SearchController(ProjectService projectService,
ProjectTypeService projectTypeService,
AreaService areaService,
PriceService priceService)
{
_ProjectService = projectService;
_ProjectTypeService = projectTypeService;
_AreaService = areaService;
_PriceService = priceService;
}
public void Assign()
{
ProjectService target = new ProjectService();
Project project = (Project) CreateRecord();
Insert(project);
target.Assign(project.ID, _manager.ID);
Assert.AreEqual(1, target.GetByUser(_manager.ID).Count);
target.Unassign(project.ID, _manager.ID);
}
public override void TestFixtureSetUp()
{
ProjectService projectService = new ProjectService();
_project = new Project("Name", "Description")
{
StartDate = DateTime.Now.AddDays(-7),
ExpEndDate = DateTime.Now.AddDays(1)
};
projectService.Insert(_project);
base.TestFixtureSetUp();
}
public void Should_Be_Able_To_Add()
{
// arrange
ProjectData projectData = new ProjectData {Description = "Test Description",};
Mock<IProjectRepository> mockProjectRepository = this.GetMockProjectRepository_ForSaving(projectData);
ProjectService projectService = new ProjectService(mockProjectRepository.Object);
// action
projectService.SaveProjectData(projectData);
// assert
mockProjectRepository.VerifyAll();
}
public void Should_Be_Able_To_Get_List_Of_All_Projects()
{
// arrange
Mock<IProjectRepository> mockProjectRepository = this.GetMockProjectRepository_List();
ProjectService projectService = new ProjectService(mockProjectRepository.Object);
// action
List<ProjectData> projectList = projectService.GetListOfAllProjects();
// assert
Assert.That(projectList, Is.Not.Null, "Projects NULL");
Assert.That(projectList.Count, Is.GreaterThan(0), "Projects - no data");
mockProjectRepository.VerifyAll();
}
public void GetProjectsForUserTest()
{
Mock<IProjectRepository> fakeProjectRepo = new Mock<IProjectRepository>();
Mock<IIssueRepository> fakeIssueRepo = new Mock<IIssueRepository>();
Mock<IApplicationUserRepository> fakeUserRepo = new Mock<IApplicationUserRepository>();
var projectService = new ProjectService(fakeProjectRepo.Object, fakeIssueRepo.Object, fakeUserRepo.Object);
var firstProjectId = Guid.NewGuid();
var secondProjectId = Guid.NewGuid();
var thirdProjectId = Guid.NewGuid();
var firstUserId = Guid.NewGuid();
var secondUserId = Guid.NewGuid();
var thirdUserId = Guid.NewGuid();
var fourthUserId = Guid.NewGuid();
List<ApplicationUser> firstAndSecondUsers = new List<ApplicationUser>()
{
new ApplicationUser {Id = firstUserId, UserName = "******" },
new ApplicationUser {Id = secondUserId, UserName = "******" }
};
List<ApplicationUser> thirdAndFourth = new List<ApplicationUser>()
{
new ApplicationUser {Id = thirdUserId, UserName = "******" },
new ApplicationUser {Id = fourthUserId, UserName = "******" }
};
var firstProject = new Project() { Active = true, Code = "my-code", CreatedAt = DateTime.Now, Id = firstProjectId, Title = "first project title", Users = firstAndSecondUsers, OwnerId = thirdUserId };
var secondProject = new Project() { Active = true, Code = "secondCode", CreatedAt = DateTime.Now, Id = secondProjectId, Title = "second project", Users = thirdAndFourth, OwnerId = firstUserId };
var secondsecondProject = new Project() { Active = true, Code = "secondCode", CreatedAt = DateTime.Now.AddDays(1), Id = secondProjectId, Title = "second project with edited title", Users = thirdAndFourth, OwnerId = firstUserId };
var thirdProject = new Project() { Active = false, Code = "thirdCode", CreatedAt = DateTime.Now, Id = thirdProjectId, Title = "third project", Users = thirdAndFourth, OwnerId = fourthUserId };
List<Project> projects = new List<Project>()
{
firstProject,
secondProject,
secondsecondProject,
thirdProject
};
fakeProjectRepo.Setup(i => i.FindBy(It.IsAny<Expression<Func<Project, bool>>>()))
.Returns((Expression<Func<Project, bool>> expression) => projects.AsQueryable().Where(expression));
var actual = projectService.GetProjectsForUser(firstUserId);
Assert.AreEqual(actual.Contains(firstProject), true);
Assert.AreEqual(actual.Contains(secondsecondProject), true);
}
public void Non_Existent_Project_ID_Should_Get_No_Records()
{
// arrange
int projectId = 0;
Mock<IProjectRepository> mockProjectRepository = this.GetMockProjectRepository_GetRecord(projectId);
ProjectService projectService = new ProjectService(mockProjectRepository.Object);
// action
ProjectData projectData = projectService.GetProjectDataByProjectId(projectId);
// assert
Assert.That(projectData, Is.Null, "Should be no project data (NULL)");
mockProjectRepository.VerifyAll();
}
public HomeController(ProjectService projectService,
ProjectTypeService projectTypeService,
AreaService areaService,
PriceService priceService,
NewsService newsService,
AdsService adsService,
ContractorServices contractorServices)
{
_ProjectService = projectService;
_ProjectTypeService = projectTypeService;
_AreaService = areaService;
_PriceService = priceService;
_NewsService = newsService;
_AdsService = adsService;
_ContractorServices = contractorServices;
}
public void Should_Be_Able_To_Update()
{
// arrange
int projectId = 1;
ProjectData projectData = helper.GetMockProjectList().Where(x => x.ProjectId == projectId).SingleOrDefault();
Mock<IProjectRepository> mockProjectRepository = this.GetMockProjectRepository_ForSaving(projectData);
ProjectService projectService = new ProjectService(mockProjectRepository.Object);
string description = "This is a Test.";
// action
projectData.Description = description;
projectService.SaveProjectData(projectData);
// assert
mockProjectRepository.VerifyAll();
}
public void DeleteAssigned()
{
ProjectService service = new ProjectService();
Project project = (Project) CreateRecord();
Insert(project);
UserService userService = new UserService();
User manager = new User(UserRole.Manager, String.Format("project{0}User", project.ID), "asdf");
userService.Insert(manager);
service.Assign(project.ID, manager.ID);
service.Delete(project.ID);
Assert.AreEqual(0, service.GetByUser(manager.ID).Count);
userService.Delete(manager.ID);
}
public void GetProjectCodeTest()
{
Mock<IProjectRepository> fakeProjectRepo = new Mock<IProjectRepository>();
Mock<IIssueRepository> fakeIssueRepo = new Mock<IIssueRepository>();
Mock<IApplicationUserRepository> fakeUserRepo = new Mock<IApplicationUserRepository>();
var projectService = new ProjectService(fakeProjectRepo.Object, fakeIssueRepo.Object, fakeUserRepo.Object);
var firstProjectId = Guid.NewGuid();
var secondProjectId = Guid.NewGuid();
List<Project> projects = new List<Project>()
{
new Project() {Active = true, Code = "my-code", CreatedAt = DateTime.Now, Id = firstProjectId, Title = "first project title" },
new Project() {Active = true, Code = "secondCode", CreatedAt = DateTime.Now, Id = secondProjectId, Title = "second project" }
};
fakeProjectRepo.Setup(i => i.FindSingleBy(It.IsAny<Expression<Func<Project, bool>>>()))
.Returns((Expression<Func<Project, bool>> expression) => projects.AsQueryable().Where(expression).SingleOrDefault());
var actual = projectService.GetProjectId("secondCode");
Assert.AreEqual(actual.Value, secondProjectId);
}
public virtual void Init()
{
WorkspaceService = new WorkspaceService(Constants.ApiToken);
var workspaces = WorkspaceService.List();
ClientService = new ClientService(Constants.ApiToken);
TaskService = new TaskService(Constants.ApiToken);
TagService = new TagService(Constants.ApiToken);
ProjectService = new ProjectService(Constants.ApiToken);
UserService = new UserService(Constants.ApiToken);
TimeEntryService = new TimeEntryService(Constants.ApiToken);
ReportService = new ReportService(Constants.ApiToken);
foreach (var workspace in workspaces)
{
var projects = WorkspaceService.Projects(workspace.Id.Value);
var tasks = WorkspaceService.Tasks(workspace.Id.Value);
var tags = WorkspaceService.Tags(workspace.Id.Value); // TODO
var users = WorkspaceService.Users(workspace.Id.Value); // TODO
var clients = WorkspaceService.Clients(workspace.Id.Value);
var rte = new TimeEntryParams { StartDate = DateTime.Now.AddYears(-1)};
var timeEntries = TimeEntryService.List(rte);
Assert.IsTrue(TimeEntryService.DeleteIfAny(timeEntries.Select(te => te.Id.Value).ToArray()));
Assert.IsTrue(ProjectService.DeleteIfAny(projects.Select(p => p.Id.Value).ToArray()));
Assert.IsTrue(TaskService.DeleteIfAny(tasks.Select(t => t.Id.Value).ToArray()));
Assert.IsTrue(ClientService.DeleteIfAny(clients.Select(c => c.Id.Value).ToArray()));
Assert.IsFalse(WorkspaceService.Projects(workspace.Id.Value).Any());
Assert.IsFalse(WorkspaceService.Tasks(workspace.Id.Value).Any());
Assert.IsFalse(WorkspaceService.Clients(workspace.Id.Value).Any());
Assert.IsFalse(TimeEntryService.List(rte).Any());
}
DefaultWorkspaceId = workspaces.First().Id.Value;
}
// GET: Project
public ActionResult Index()
{
var projectService = new ProjectService();
return(View(projectService.ListProjects()));
}
/// <summary>
/// Initializes a new instance of the ProjectsController class.
/// </summary>
/// <param name="projectService">Project service instance</param>
/// <param name="lookupService">The lookup service.</param>
/// <param name="developerService">The developer service.</param>
/// <param name="projectStackHolderService">The project stack holder service.</param>
public ProjectsController(ProjectService projectService, LookupService lookupService, DeveloperService developerService, ProjectStackHolderService projectStackHolderService)
{
this.projectService = projectService;
this.lookupService = lookupService;
this.developerService = developerService;
this.projectStakeHolderService = projectStackHolderService;
}
public void ShouldReturnNullIfEmployeeNotExists()
{
IProjectService service = new ProjectService();
Assert.IsNull(service.RetrieveProjects(100));
}
private async Task SynchronizeProjects()
{
var projects = await ProjectService.GetUnsynced(AppSettings.LastSyncDate);
ProjectRepository.AddOrUpdate(projects);
}
public void Initialize()
{
var mockDb = new MockDataContext();
#region Initialize projects.
var p1 = new Project
{
ID = 1,
_projectName = "Project_1",
_projectFileTypeId = 1,
};
mockDb._projects.Add(p1);
var p2 = new Project
{
ID = 2,
_projectName = "Project_2",
_projectFileTypeId = 2
};
mockDb._projects.Add(p2);
var p3 = new Project
{
ID = 3,
_projectName = "Project_3",
_projectFileTypeId = 3
};
mockDb._projects.Add(p3);
var p4 = new Project
{
ID = 4,
_projectName = "Project_4",
_projectFileTypeId = 4
};
mockDb._projects.Add(p4);
var p5 = new ProjectFile
{
ID = 1,
_projectID = 1,
_projectFileName = "lab1",
_projectFileType = "html",
_aceExtension = "html",
_projectFileData = "hello"
};
mockDb._projectFiles.Add(p5);
var p6 = new ProjectOwner
{
ID = 1,
_projectID = 1,
_userName = "******"
};
mockDb._projectOwners.Add(p6);
var p7 = new ProjectFileViewModel
{
_id = 1,
_projectFileData = "dada",
_projectID = 1,
_projectFileName = "lab98"
};
mockDb._projectFileViewModel.Add(p7);
var p8 = new ProjectViewModel
{
_id = 1,
_isProjectOwner = true,
_projectName = "String"
};
mockDb._projectViewModel.Add(p8);
var p9 = new ApplicationUserViewModel
{
_applicationUserName = "******"
//_applicationUserProjects ""
};
mockDb.UserViewModel.Add(p9);
#endregion
_service = new ProjectService(mockDb);
}
public ProjectKeysController()
{
projservice = new ProjectService();
}
public override FileTemplateResult Create(FileTemplateOptions options)
{
FileTemplateResult result = new FileTemplateResult(options);
StandardHeader.SetHeaders();
StringParserPropertyContainer.FileCreation["StandardNamespace"] = options.Namespace;
StringParserPropertyContainer.FileCreation["FullName"] = options.FileName;
StringParserPropertyContainer.FileCreation["FileName"] = Path.GetFileName(options.FileName);
StringParserPropertyContainer.FileCreation["FileNameWithoutExtension"] = Path.GetFileNameWithoutExtension(options.FileName);
StringParserPropertyContainer.FileCreation["Extension"] = Path.GetExtension(options.FileName);
StringParserPropertyContainer.FileCreation["Path"] = Path.GetDirectoryName(options.FileName);
StringParserPropertyContainer.FileCreation["ClassName"] = options.ClassName;
// when adding a file to a project (but not when creating a standalone file while a project is open):
var project = options.Project;
if (project != null && !options.IsUntitled)
{
// add required assembly references to the project
foreach (ReferenceProjectItem reference in RequiredAssemblyReferences)
{
IEnumerable <ProjectItem> refs = project.GetItemsOfType(ItemType.Reference);
if (!refs.Any(projItem => string.Equals(projItem.Include, reference.Include, StringComparison.OrdinalIgnoreCase)))
{
ReferenceProjectItem projItem = (ReferenceProjectItem)reference.CloneFor(project);
ProjectService.AddProjectItem(project, projItem);
ProjectBrowserPad.RefreshViewAsync();
}
}
}
foreach (FileDescriptionTemplate newfile in FileDescriptionTemplates)
{
if (!IsFilenameAvailable(StringParser.Parse(newfile.Name)))
{
MessageService.ShowError(string.Format("Filename {0} is in use.\nChoose another one", StringParser.Parse(newfile.Name))); // TODO : translate
return(null);
}
}
try {
var filesToOpen = new List <FileName>();
ScriptRunner scriptRunner = new ScriptRunner();
foreach (FileDescriptionTemplate newFile in FileDescriptionTemplates)
{
FileOperationResult opresult = FileUtility.ObservedSave(
() => {
OpenedFile resultFile;
bool shouldOpen;
if (!String.IsNullOrEmpty(newFile.BinaryFileName))
{
resultFile = SaveFile(newFile, null, newFile.BinaryFileName, options, out shouldOpen);
}
else
{
resultFile = SaveFile(newFile, scriptRunner.CompileScript(this, newFile), null, options, out shouldOpen);
}
if (resultFile != null)
{
result.NewOpenedFiles.Add(resultFile);
result.NewFiles.Add(resultFile.FileName);
if (shouldOpen)
{
filesToOpen.Add(resultFile.FileName);
}
}
}, FileName.Create(StringParser.Parse(newFile.Name))
);
if (opresult != FileOperationResult.OK)
{
return(null);
}
}
// Run creation actions
if (createActions != null)
{
createActions(result);
}
foreach (var filename in filesToOpen.Intersect(result.NewFiles))
{
SD.FileService.OpenFile(filename);
}
} finally {
// Now that the view contents
foreach (var file in result.NewOpenedFiles)
{
file.CloseIfAllViewsClosed();
}
result.NewOpenedFiles.RemoveAll(f => f.RegisteredViewContents.Count == 0);
}
// raise FileCreated event for the new files.
foreach (var fileName in result.NewFiles)
{
FileService.FireFileCreated(fileName, false);
}
if (project != null)
{
project.Save();
}
return(result);
}
public void GetLastEmployeesHistoryTest()
{
ParticipationHistoryService participationHistoryService = new ParticipationHistoryService(uow, new Map <ParticipationHistory, ParticipationHistoryDTO>());
EmployeeService employeeService = new EmployeeService(uow, new Map <Employee, EmployeeDTO>());
ProjectService projectService = new ProjectService(uow, new Map <Project, ProjectDTO>());
ProjectWorkService projectWorkService = new ProjectWorkService(uow, new Map <ProjectWork, ProjectWorkDTO>());
EmployeeDTO employee = new EmployeeDTO
{
EmployeeName = "Екатерина",
EmployeeSurname = "Антонович",
EmployeePatronymic = "Алексеевна",
RoleId = 3,
Email = "*****@*****.**",
};
var employeeOnWork = employeeService.CreateEmployee(employee);
var em = employeeService.GetEmployeeById(employeeOnWork.Id);
ProjectDTO project = new ProjectDTO
{
ProjectName = "проект 1",
ProjectDescription = "проект номер один",
ProjectStartDate = new DateTimeOffset(2021, 10, 6, 10, 15, 35, new TimeSpan(3, 0, 0)),
ProjectEndDate = new DateTimeOffset(2021, 11, 21, 10, 15, 35, new TimeSpan(3, 0, 0))
};
var proj = projectService.CreateProject(project);
var pr = projectService.GetProjectById(proj.Id);
ProjectWorkDTO projectWork = new ProjectWorkDTO
{
EmployeeId = em.Id,
ProjectId = pr.Id,
ProjectRoleId = 3
};
var pWork = projectWorkService.CreateProjectWork(projectWork);
var prw = projectWorkService.GetProjectWorkById(pWork.Id);
ParticipationHistoryDTO participationHistory1 = new ParticipationHistoryDTO
{
ProjectWorkId = prw.Id,
StartDate = new DateTimeOffset(2021, 10, 16, 10, 15, 35, new TimeSpan(3, 0, 0)),
EndDate = new DateTimeOffset(2021, 11, 04, 11, 15, 35, new TimeSpan(3, 0, 0))
};
var errors = phvalidator.Validate(participationHistory1);
var history1 = participationHistoryService.CreateHistory(participationHistory1);
var actual1 = participationHistoryService.GetHistoryById(history1.Id);
ParticipationHistoryDTO participationHistory2 = new ParticipationHistoryDTO
{
ProjectWorkId = prw.Id,
StartDate = new DateTimeOffset(2021, 11, 05, 10, 15, 35, new TimeSpan(3, 0, 0)),
EndDate = new DateTimeOffset(2021, 11, 21, 11, 15, 35, new TimeSpan(3, 0, 0))
};
var errors2 = phvalidator.Validate(participationHistory2);
var history2 = participationHistoryService.CreateHistory(participationHistory2);
var actual2 = participationHistoryService.GetHistoryById(history2.Id);
var actual = participationHistoryService.GetLastEmployeesHistory(prw.Id);
ParticipationHistoryDTO expected = new ParticipationHistoryDTO
{
Id = actual2.Id,
ProjectWorkId = prw.Id,
StartDate = new DateTimeOffset(2021, 11, 05, 10, 15, 35, new TimeSpan(3, 0, 0)),
EndDate = new DateTimeOffset(2021, 11, 21, 11, 15, 35, new TimeSpan(3, 0, 0))
};
Assert.IsTrue(errors.Count == 0 && errors2.Count == 0 && actual.Id == expected.Id && actual.ProjectWorkId == expected.ProjectWorkId &&
actual.StartDate == expected.StartDate && actual.EndDate == expected.EndDate);
participationHistoryService.DeleteHistoryById(actual1.Id);
participationHistoryService.DeleteHistoryById(actual2.Id);
projectWorkService.DeleteProjectWorkById(prw.Id);
employeeService.DeleteEmployeeById(em.Id);
projectService.DeleteProjectById(pr.Id);
}
private static void InitializeServices(int id)
{
TagService.Initialize(id);
ProjectService.Initialize(id);
ToDoItemService.Initialize(id);
}
public static void CopyDirectory(string directoryName, DirectoryNode node, bool includeInProject)
{
directoryName = FileUtility.NormalizePath(directoryName);
string copiedFileName = Path.Combine(node.Directory, Path.GetFileName(directoryName));
LoggingService.Debug("Copy " + directoryName + " to " + copiedFileName);
if (!FileUtility.IsEqualFileName(directoryName, copiedFileName))
{
if (includeInProject && ProjectService.OpenSolution != null)
{
// get ProjectItems in source directory
foreach (IProject project in ProjectService.OpenSolution.Projects)
{
if (!FileUtility.IsBaseDirectory(project.Directory, directoryName))
{
continue;
}
LoggingService.Debug("Searching for child items in " + project.Name);
foreach (ProjectItem item in project.Items)
{
FileProjectItem fileItem = item as FileProjectItem;
if (fileItem == null)
{
continue;
}
string virtualFullName = Path.Combine(project.Directory, fileItem.VirtualName);
if (FileUtility.IsBaseDirectory(directoryName, virtualFullName))
{
if (item.ItemType == ItemType.Folder && FileUtility.IsEqualFileName(directoryName, virtualFullName))
{
continue;
}
LoggingService.Debug("Found file " + virtualFullName);
FileProjectItem newItem = new FileProjectItem(node.Project, fileItem.ItemType);
if (FileUtility.IsBaseDirectory(directoryName, fileItem.FileName))
{
newItem.FileName = FileName.Create(FileUtility.RenameBaseDirectory(fileItem.FileName, directoryName, copiedFileName));
}
else
{
newItem.FileName = fileItem.FileName;
}
fileItem.CopyMetadataTo(newItem);
if (fileItem.IsLink)
{
string newVirtualFullName = FileUtility.RenameBaseDirectory(virtualFullName, directoryName, copiedFileName);
fileItem.SetEvaluatedMetadata("Link", FileUtility.GetRelativePath(node.Project.Directory, newVirtualFullName));
}
ProjectService.AddProjectItem(node.Project, newItem);
}
}
}
}
FileService.CopyFile(directoryName, copiedFileName, true, false);
DirectoryNode newNode = new DirectoryNode(copiedFileName);
newNode.InsertSorted(node);
if (includeInProject)
{
IncludeFileInProject.IncludeDirectoryNode(newNode, false);
}
newNode.Expanding();
}
else if (includeInProject)
{
foreach (TreeNode childNode in node.Nodes)
{
if (childNode is DirectoryNode)
{
DirectoryNode directoryNode = (DirectoryNode)childNode;
if (FileUtility.IsEqualFileName(directoryNode.Directory, copiedFileName))
{
IncludeFileInProject.IncludeDirectoryNode(directoryNode, true);
}
}
}
}
}
protected IEnumerable <FileProjectItem> AddExistingItems()
{
DirectoryNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedDirectoryNode;
if (node == null)
{
return(null);
}
node.Expanding();
node.Expand();
List <FileProjectItem> addedItems = new List <FileProjectItem>();
using (OpenFileDialog fdiag = new OpenFileDialog()) {
fdiag.AddExtension = true;
var fileFilters = ProjectService.GetFileFilters();
fdiag.InitialDirectory = node.Directory;
fdiag.FilterIndex = GetFileFilterIndex(node.Project, fileFilters);
fdiag.Filter = String.Join("|", fileFilters);
fdiag.Multiselect = true;
fdiag.CheckFileExists = true;
fdiag.Title = StringParser.Parse("${res:ProjectComponent.ContextMenu.AddExistingFiles}");
if (fdiag.ShowDialog(SD.WinForms.MainWin32Window) == DialogResult.OK)
{
List <KeyValuePair <string, string> > fileNames = new List <KeyValuePair <string, string> >(fdiag.FileNames.Length);
foreach (string fileName in fdiag.FileNames)
{
fileNames.Add(new KeyValuePair <string, string>(fileName, ""));
}
bool addedDependentFiles = false;
foreach (string fileName in fdiag.FileNames)
{
foreach (string additionalFile in FindAdditionalFiles(fileName))
{
if (!fileNames.Exists(delegate(KeyValuePair <string, string> pair) {
return(FileUtility.IsEqualFileName(pair.Key, additionalFile));
}))
{
addedDependentFiles = true;
fileNames.Add(new KeyValuePair <string, string>(additionalFile, Path.GetFileName(fileName)));
}
}
}
string copiedFileName = Path.Combine(node.Directory, Path.GetFileName(fileNames[0].Key));
if (!FileUtility.IsEqualFileName(fileNames[0].Key, copiedFileName))
{
int res = MessageService.ShowCustomDialog(
fdiag.Title, "${res:ProjectComponent.ContextMenu.AddExistingFiles.Question}",
0, 2,
"${res:ProjectComponent.ContextMenu.AddExistingFiles.Copy}",
"${res:ProjectComponent.ContextMenu.AddExistingFiles.Link}",
"${res:Global.CancelButtonText}");
if (res == 1)
{
// Link
foreach (KeyValuePair <string, string> pair in fileNames)
{
string fileName = pair.Key;
string relFileName = FileUtility.GetRelativePath(node.Project.Directory, fileName);
FileNode fileNode = new FileNode(fileName, FileNodeStatus.InProject);
FileProjectItem fileProjectItem = new FileProjectItem(node.Project, node.Project.GetDefaultItemType(fileName), relFileName);
fileProjectItem.SetEvaluatedMetadata("Link", Path.Combine(node.RelativePath, Path.GetFileName(fileName)));
fileProjectItem.DependentUpon = pair.Value;
addedItems.Add(fileProjectItem);
fileNode.ProjectItem = fileProjectItem;
fileNode.InsertSorted(node);
ProjectService.AddProjectItem(node.Project, fileProjectItem);
}
node.Project.Save();
if (addedDependentFiles)
{
node.RecreateSubNodes();
}
return(addedItems.AsReadOnly());
}
if (res == 2)
{
// Cancel
return(addedItems.AsReadOnly());
}
// only continue for res==0 (Copy)
}
bool replaceAll = false;
foreach (KeyValuePair <string, string> pair in fileNames)
{
copiedFileName = Path.Combine(node.Directory, Path.GetFileName(pair.Key));
if (!replaceAll && File.Exists(copiedFileName) && !FileUtility.IsEqualFileName(pair.Key, copiedFileName))
{
ReplaceExistingFile res = ShowReplaceExistingFileDialog(fdiag.Title, Path.GetFileName(pair.Key), true);
if (res == ReplaceExistingFile.YesToAll)
{
replaceAll = true;
}
else if (res == ReplaceExistingFile.No)
{
continue;
}
else if (res == ReplaceExistingFile.Cancel)
{
break;
}
}
FileProjectItem item = CopyFile(pair.Key, node, true);
if (item != null)
{
addedItems.Add(item);
item.DependentUpon = pair.Value;
}
}
node.Project.Save();
if (addedDependentFiles)
{
node.RecreateSubNodes();
}
}
}
return(addedItems.AsReadOnly());
}
private void DeleteProjectVM_OnDelete(object sender, EventArgs e)
{
ProjectService.DeleteCurrentlyOpenedProject();
OnGoBackClick?.Invoke(this, null);
}
public static void Load()
{
CreateSnippetProject();
CreateSnippetFile();
ProjectService.LoadProject(SnippetProjectFileName);
}
/// <summary>
///获取有待审核任务的项目列表
/// </summary>
/// <returns></returns>
public List<Project> GetProjContainsTasksUnchecked()
{
ProjectService ps = new ProjectService();
List<Project> list = ps.FindByTaskProcessStatus(EnumTaskProcessStatus.Confirmed);
return list;
}
public LogInController(UserService us, ProjectService ps)
{
userSevice = us;
projectService = ps;
}
public void LoadMakesProjectNotDirty()
{
project.Save( xmlfile );
NUnitProject project2 = new ProjectService().LoadProject( xmlfile );
Assert.IsFalse( project2.IsDirty );
}
public IProject CreateProject(ProjectCreateInformation projectCreateInformation, string defaultLanguage)
{
// remember old outerProjectBasePath
string outerProjectBasePath = projectCreateInformation.ProjectBasePath;
string outerProjectName = projectCreateInformation.ProjectName;
try
{
projectCreateInformation.ProjectBasePath = Path.Combine(projectCreateInformation.ProjectBasePath, this.relativePath);
if (!Directory.Exists(projectCreateInformation.ProjectBasePath))
{
Directory.CreateDirectory(projectCreateInformation.ProjectBasePath);
}
string language = string.IsNullOrEmpty(languageName) ? defaultLanguage : languageName;
LanguageBindingDescriptor descriptor = LanguageBindingService.GetCodonPerLanguageName(language);
ILanguageBinding languageinfo = (descriptor != null) ? descriptor.Binding : null;
if (languageinfo == null)
{
StringParser.Properties["type"] = language;
MessageService.ShowError("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.CantCreateProjectWithTypeError}");
return(null);
}
string newProjectName = StringParser.Parse(name, new string[, ] {
{ "ProjectName", projectCreateInformation.ProjectName }
});
string projectLocation = Path.GetFullPath(Path.Combine(projectCreateInformation.ProjectBasePath,
newProjectName + LanguageBindingService.GetProjectFileExtension(language)));
StringBuilder standardNamespace = new StringBuilder();
// filter 'illegal' chars from standard namespace
if (newProjectName != null && newProjectName.Length > 0)
{
char ch = '.';
for (int i = 0; i < newProjectName.Length; ++i)
{
if (ch == '.')
{
// at beginning or after '.', only a letter or '_' is allowed
ch = newProjectName[i];
if (!Char.IsLetter(ch))
{
standardNamespace.Append('_');
}
else
{
standardNamespace.Append(ch);
}
}
else
{
ch = newProjectName[i];
// can only contain letters, digits or '_'
if (!Char.IsLetterOrDigit(ch) && ch != '.')
{
standardNamespace.Append('_');
}
else
{
standardNamespace.Append(ch);
}
}
}
}
projectCreateInformation.OutputProjectFileName = projectLocation;
projectCreateInformation.RootNamespace = standardNamespace.ToString();
projectCreateInformation.ProjectName = newProjectName;
StringParser.Properties["StandardNamespace"] = projectCreateInformation.RootNamespace;
IProject project;
try {
project = languageinfo.CreateProject(projectCreateInformation);
} catch (ProjectLoadException ex) {
MessageService.ShowError(ex.Message);
return(null);
}
// Add Project items
foreach (ProjectItem projectItem in projectItems)
{
ProjectItem newProjectItem = new UnknownProjectItem(
project,
StringParser.Parse(projectItem.ItemType.ItemName),
StringParser.Parse(projectItem.Include)
);
foreach (string metadataName in projectItem.MetadataNames)
{
string metadataValue = projectItem.GetMetadata(metadataName);
// if the input contains any special MSBuild sequences, don't escape the value
// we want to escape only when the special characters are introduced by the StringParser.Parse replacement
if (metadataValue.Contains("$(") || metadataValue.Contains("%"))
{
newProjectItem.SetMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue));
}
else
{
newProjectItem.SetEvaluatedMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue));
}
}
((IProjectItemListProvider)project).AddProjectItem(newProjectItem);
}
// Add Imports
if (clearExistingImports || projectImports.Count > 0)
{
if (!(project is MSBuildBasedProject))
{
throw new Exception("<Imports> may be only used in project templates for MSBuildBasedProjects");
}
if (clearExistingImports)
{
MSBuildInternals.ClearImports(((MSBuildBasedProject)project).MSBuildProject);
}
try {
foreach (Import projectImport in projectImports)
{
((MSBuildBasedProject)project).MSBuildProject.AddNewImport(projectImport.Key, projectImport.Value);
}
((MSBuildBasedProject)project).CreateItemsListFromMSBuild();
} catch (MSBuild.InvalidProjectFileException ex) {
if (string.IsNullOrEmpty(importsFailureMessage))
{
MessageService.ShowError("Error creating project:\n" + ex.Message);
}
else
{
MessageService.ShowError(importsFailureMessage + "\n\n" + ex.Message);
}
return(null);
}
}
if (projectProperties.Count > 0)
{
if (!(project is MSBuildBasedProject))
{
throw new Exception("<PropertyGroup> may be only used in project templates for MSBuildBasedProjects");
}
foreach (ProjectProperty p in projectProperties)
{
((MSBuildBasedProject)project).SetProperty(
StringParser.Parse(p.Configuration),
StringParser.Parse(p.Platform),
StringParser.Parse(p.Name),
StringParser.Parse(p.Value),
p.Location,
p.ValueIsLiteral
);
}
}
// Add Files
foreach (FileDescriptionTemplate file in files)
{
string fileName = Path.Combine(projectCreateInformation.ProjectBasePath, StringParser.Parse(file.Name, new string[, ] {
{ "ProjectName", projectCreateInformation.ProjectName }
}));
FileProjectItem projectFile = new FileProjectItem(project, project.GetDefaultItemType(fileName));
projectFile.Include = FileUtility.GetRelativePath(project.Directory, fileName);
file.SetProjectItemProperties(projectFile);
((IProjectItemListProvider)project).AddProjectItem(projectFile);
if (File.Exists(fileName))
{
StringParser.Properties["fileName"] = fileName;
if (!MessageService.AskQuestion("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion}", "${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}"))
{
continue;
}
}
try {
if (!Directory.Exists(Path.GetDirectoryName(fileName)))
{
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
}
if (file.ContentData != null)
{
// Binary content
File.WriteAllBytes(fileName, file.ContentData);
}
else
{
// Textual content
StreamWriter sr = new StreamWriter(File.Create(fileName), ParserService.DefaultFileEncoding);
string fileContent = StringParser.Parse(file.Content, new string[, ] {
{ "ProjectName", projectCreateInformation.ProjectName }, { "FileName", fileName }
});
fileContent = StringParser.Parse(fileContent);
if (SharpDevelopTextEditorProperties.Instance.IndentationString != "\t")
{
fileContent = fileContent.Replace("\t", SharpDevelopTextEditorProperties.Instance.IndentationString);
}
sr.Write(fileContent);
sr.Close();
}
} catch (Exception ex) {
StringParser.Properties["fileName"] = fileName;
MessageService.ShowError(ex, "${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.FileCouldntBeWrittenError}");
}
}
RunCreateActions(project);
// Save project
if (File.Exists(projectLocation))
{
StringParser.Properties["projectLocation"] = projectLocation;
if (MessageService.AskQuestion("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteProjectQuestion}", "${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}"))
{
project.Save();
}
}
else
{
project.Save();
}
projectCreateInformation.createdProjects.Add(project);
ProjectService.OnProjectCreated(new ProjectEventArgs(project));
return(project);
}
finally
{
// set back outerProjectBasePath
projectCreateInformation.ProjectBasePath = outerProjectBasePath;
projectCreateInformation.ProjectName = outerProjectName;
}
}
public UserDashboard()
{
_insendluEntities = new InsendluEntities();
_projectService = new ProjectService();
_imageService = new ImageService();
}
void RemoveFirstProjectItem()
{
ProjectItem item = project.Items[0];
ProjectService.RemoveProjectItem(project, item);
}
public ListProjects(ProjectService projectService)
{
_projectService = projectService;
}
public JsonResult IsProjectAvail(string projectCode)
{
var projectService = new ProjectService();
return(Json(projectService.IsProjectCodeDuplicate(projectCode), JsonRequestBehavior.AllowGet));
}
public Migration(IConfiguration configuration, BucketPrefixProvider bucketPrefix, IForgeOSS forgeOSS, MigrationBucketKeyProvider bucketProvider, UserResolver userResolver, ProjectWork projectWork, ILogger <Migration> logger, ResourceProvider resourceProvider, OssBucketFactory bucketFactory, ProjectService projectService)
{
_forgeOSS = forgeOSS;
_configuration = configuration;
_bucketPrefix = bucketPrefix;
_bucketProvider = bucketProvider;
_userResolver = userResolver;
_projectWork = projectWork;
_logger = logger;
_resourceProvider = resourceProvider;
_bucketFactory = bucketFactory;
_projectService = projectService;
}
public void RemoveProjectItem(IProject project, ProjectItem item)
{
ProjectService.RemoveProjectItem(project, item);
}
public ProjectsController(ProjectService projectService)
{
_projectService = projectService;
}
public void GetProjectsTest()
{
Mock<IProjectRepository> fakeProjectRepo = new Mock<IProjectRepository>();
Mock<IIssueRepository> fakeIssueRepo = new Mock<IIssueRepository>();
Mock<IApplicationUserRepository> fakeUserRepo = new Mock<IApplicationUserRepository>();
var projectService = new ProjectService(fakeProjectRepo.Object, fakeIssueRepo.Object, fakeUserRepo.Object);
var firstProjectId = Guid.NewGuid();
var secondProjectId = Guid.NewGuid();
var thirdProjectId = Guid.NewGuid();
List<Project> projects = new List<Project>()
{
new Project() {Active = true, Code = "my-code", CreatedAt = DateTime.Now, Id = firstProjectId, Title = "first project title" },
new Project() {Active = true, Code = "secondCode", CreatedAt = DateTime.Now, Id = secondProjectId, Title = "second project" },
new Project() {Active = true, Code = "secondCode", CreatedAt = DateTime.Now.AddDays(1), Id = secondProjectId, Title = "second project with edited title" },
new Project() {Active = false, Code = "thirdCode", CreatedAt = DateTime.Now, Id = thirdProjectId, Title = "third project" }
};
fakeProjectRepo.Setup(i => i.Fetch()).Returns(projects.AsQueryable());
var actual = projectService.GetProjects();
Assert.AreEqual(actual.Count(), 2);
}
public ProjectNameResolverAttribute(string resolverKey)
{
_projectService = new ProjectService();
ResolverKey = resolverKey;
}
protected override void Initialize(RequestContext requestContext)
{
base.Initialize(requestContext);
_service = new ProjectService(CurrAccountNo);
}
public void ProjectCodeIsNotUniqueTest()
{
Mock<IProjectRepository> fakeProjectRepo = new Mock<IProjectRepository>();
Mock<IIssueRepository> fakeIssueRepo = new Mock<IIssueRepository>();
Mock<IApplicationUserRepository> fakeUserRepo = new Mock<IApplicationUserRepository>();
var projectService = new ProjectService(fakeProjectRepo.Object, fakeIssueRepo.Object, fakeUserRepo.Object);
var firstProjectId = Guid.NewGuid();
var secondProjectId = Guid.NewGuid();
var thirdProjectId = Guid.NewGuid();
var firstProject = new Project() { Active = true, Code = "my-code", CreatedAt = DateTime.Now, Id = firstProjectId, Title = "first project title" };
var secondProject = new Project() { Active = true, Code = "SECONDCODE", CreatedAt = DateTime.Now, Id = secondProjectId, Title = "second project" };
var secondsecondProject = new Project() { Active = true, Code = "SECONDCODE", CreatedAt = DateTime.Now.AddDays(1), Id = secondProjectId, Title = "second project with edited title" };
var thirdProject = new Project() { Active = false, Code = "thirdCode", CreatedAt = DateTime.Now, Id = thirdProjectId, Title = "third project" };
List<Project> projects = new List<Project>()
{
firstProject,
secondProject,
secondsecondProject,
thirdProject
};
fakeProjectRepo.Setup(i => i.GetAll()).Returns(projects);
var actual = projectService.ProjectCodeIsNotUnique("secondCode");
var expected = true;
Assert.AreEqual(expected, actual);
actual = projectService.ProjectCodeIsNotUnique("newcode");
expected = false;
Assert.AreEqual(expected, actual);
}
public ProjectVM(ProjectService projectService, ProjectFolderVM projectFolderVM)
{
//InputVMs...
ProjectService = projectService;
ProjectFolderVM = projectFolderVM;
}
public Research()
{
_projectService = new ProjectService();
}
public Report()
{
_insendluEntities = new InsendluEntities();
_projectService = new ProjectService();
}
public async Task <IActionResult> DeleteConfirmed(string projectName)
{
await ProjectService.DeleteProjectAsync(ClassroomName, projectName);
return(RedirectToAction("Admin"));
}
public ContributionController(ContributionService contributionService, ProjectService projectService)
{
this.projectService = projectService;
this.contributionService = contributionService;
}
/// <summary>
///获取有至少一条任何状态任务的项目列表
/// </summary>
/// <returns></returns>
public List<Project> GetAllProj()
{
ProjectService ps = new ProjectService();
List<Project> list = ps.FindContainsAnyTask();
return list;
}
public async Task <IActionResult> Admin()
{
var projects = await ProjectService.GetProjectsAsync(ClassroomName);
return(View(projects));
}
public void SetUp()
{
projectService = new ProjectService();
project = projectService.EmptyProject();
}
public void AddProjectItem(IProject project, ProjectItem item)
{
ProjectService.AddProjectItem(project, item);
}
