private async Task <bool> GetAllProjects(Guid?selectedProjectId = null)
{
try
{
if (selectedProjectId != null)
{
viewModel.Projects = null;
viewModel.SelectedProject = null;
}
var obsProjects = await ProjectsService.GetAllProjectsActiveAndPlanningUserCanView();
ObservableCollection <ProjectInsight.Models.Projects.Project> projects = new ObservableCollection <ProjectInsight.Models.Projects.Project>(obsProjects);
//viewModel.Projects = createInitElem(projects, new ProjectInsight.Models.Projects.Project());
viewModel.Projects = projects;
if (selectedProjectId != null)
{
viewModel.SelectedProject = viewModel.Projects.Where(x => x.Id == selectedProjectId).FirstOrDefault();
}
}
catch (Exception ex)
{
//AuthenticationService.Logout();
return(false);
}
return(true);
}
public async Task GetProjectLogo()
{
// Arrange
ProjectsService svc = new ProjectsService(await GetAuthenticationService());
// Act
var projects = await svc.GetProjects();
if (projects?.Count() > 0)
{
var first = projects.First();
int width = 100, height = 100;
var stream = await svc.GetProjectLogo(first.Id, width, height);
// Create a .NET memory stream.
var memStream = new MemoryStream();
// Convert the stream to the memory stream, because a memory stream supports seeking.
await stream.CopyToAsync(memStream);
// Set the start position.
memStream.Position = 0;
// UI Thread needed
await ExecuteOnUIThreadAsync(() =>
{
// Create a new bitmap image.
var bitmap = new Windows.UI.Xaml.Media.Imaging.BitmapImage();
// Set the bitmap source to the stream, which is converted to a IRandomAccessStream.
bitmap.SetSource(memStream.AsRandomAccessStream());
});
}
// Assert
// TODO
}
public async Task WhenUpdatingExistingProject_UpdateSuccessfully(int id, string title, string description, int categoryId, string category, DateTime startDate, DateTime endDate)
{
var options = Helper.GetContextOptions();
CreateTestData(options);
using (var context = new DataContext(options))
{
var service = new ProjectsService(context);
var projectDto = new ProjectDto
{
Id = id,
Title = title,
Description = description,
ProjectCategoryId = categoryId,
StartDate = startDate,
EndDate = endDate
};
await service.UpdateAsync(projectDto);
var updatedProject = await service.GetAsync(id);
ValidateProject(updatedProject, id, title, description, category, startDate, endDate);
}
}
public async Task GetProjects_Without_Authentication()
{
// Arrange
ProjectsService svc = new ProjectsService(new AuthenticationService());
// Act and Assert
await Assert.ThrowsExceptionAsync <NotAuthenticatedException>(async() => await svc.GetProjects());
}
public async Task WhenPassingCorrectData_SuccessfullyCreate(string title, string description, int categoryId, string category, DateTime startDate, DateTime endDate)
{
DateTime d1 = new DateTime(2011, 1, 1);
DateTime d2 = DateTime.Now;
DateTime d3 = DateTime.UtcNow;
DateTime d4 = DateTime.Parse("2011-1-1");
var options = Helper.GetContextOptions();
CreateTestData(options);
using (var context = new DataContext(options))
{
var service = new ProjectsService(context);
var projectDto = new ProjectDto
{
Title = title,
Description = description,
ProjectCategoryId = categoryId,
StartDate = startDate,
EndDate = endDate
};
var id = await service.CreateAsync(projectDto);
var project = await service.GetAsync(id);
ValidateProject(project, null, title, description, category, startDate, endDate);
}
}
public void UpdateMapping(MappingModel model)
{
var template = TemplateService.GetSingleTemplate(model.GcTemplate.Id);
var project = ProjectsService.GetSingleProject(template.Data.ProjectId.ToString());
var templateMapping = new TemplateMapping
{
MappingId = model.MappingId,
MappingTitle = model.MappingTitle,
DefaultLocationId = model.DefaultLocationId,
GcProjectId = project.Data.Id.ToString(),
CmsTemplate = new CmsTemplate
{
TemplateId = model.CmsTemplate.Id
},
GcTemplate = new GcTemplate
{
GcTemplateId = template.Data.Id.ToString(),
GcTemplateName = template.Data.Name
},
};
var fieldMappings = ConvertToFieldMappings(model.FieldMappings);
templateMapping.FieldMappings = fieldMappings;
MappingRepository.UpdateMapping(templateMapping);
}
public void Init()
{
_projectsRepositoryMock = new Mock <IItemRepository <Project> >();
_tasksRepositoryMock = new Mock <IItemRepository <Task> >();
_mapperMock = new Mock <IMapper>();
_projectsService = new ProjectsService(_projectsRepositoryMock.Object, _tasksRepositoryMock.Object, _mapperMock.Object);
}
public async Task SubmitForm()
{
if (OrganizationsService.OrganizationExists(SelectedOrganization.Id) && ProjectsService.ProjectExists(EpicEntity.ProjectId))
{
EpicEntity.Project = await ProjectsService.GetProjectOrNull(EpicEntity.ProjectId);
await SaveOrganization();
}
}
public void should_succeed_if_return_all()
{
var pservice = new ProjectsService();
var pcontroller = new ProjectsController(pservice);
var res = pcontroller.GetProjects().Result;
Assert.IsTrue(res.Count() > 0);
}
public async Task ProjectExistsAsync_ShouldReturnFalse_ForNonExistentName()
{
var service = new ProjectsService(Db, UserManager);
var result = await service.ProjectExistsAsync("Project 0");
result.Should().BeFalse();
}
public async Task ProjectExistsAsync_ShouldReturnTrue()
{
var service = new ProjectsService(Db, UserManager);
var result = await service.ProjectExistsAsync(TestProjectName1);
result.Should().BeTrue();
}
public async Task ProjectExistsAsync_ShouldReturnFalse_ForExcludedId()
{
var service = new ProjectsService(Db, UserManager);
var result = await service.ProjectExistsAsync(TestProjectName1, 1);
result.Should().BeFalse();
}
public ProjectsViewModel()
{
_projectsService = DependencyService.Resolve <ProjectsService>();
RefreshCommand = new AsyncCommand(RefreshCollectionAsync);
CreateProjectCommand = new Command(CreateProject);
SelectedCommand = new Command <object>(OnProjectSelected);
}
/// <summary>
///
/// </summary>
/// <param name="projectId"></param>
/// <param name="gcItemIds"></param>
/// <returns></returns>
public Dictionary <string, List <ItemEntity> > GetItemsMap(string projectId, IEnumerable <string> gcItemIds)
{
List <ItemEntity> items = new List <ItemEntity>();
Dictionary <string, List <ItemEntity> > paths = new Dictionary <string, List <ItemEntity> >();
var accounts = AccountsService.GetAccounts();
var account = accounts.Data.FirstOrDefault();
if (account != null)
{
var project = ProjectsService.GetProjects(account.Id).Data.FirstOrDefault(p => p.Active && p.Id.ToString() == projectId);
if (project != null)
{
foreach (var gcItemId in gcItemIds)
{
string itemInPathId = gcItemId;
ItemEntity item = null;
List <ItemEntity> path = new List <ItemEntity>();
while (true)
{
if (items.All(x => x.Data.Id.ToString() != itemInPathId)) //if we've not requested it yet
{
var gcItem = ItemsService.GetSingleItem(itemInPathId);
if (gcItem != null)
{
item = gcItem;
items.Add(item);
}
else
{
}
}
else
{
item = items.First(x => x.Data.Id.ToString() == itemInPathId);
}
if (item != null)
{
path.Add(item);
if (item.Data.ParentId != 0)
{
itemInPathId = item.Data.ParentId.ToString();
continue;
}
}
break;
}
path.Reverse();
paths.Add(gcItemId, path);
}
return(paths);
}
}
return(null);
}
protected override void Initialize(IViewContext context)
{
_projectsController = SdlTradosStudio.Application.GetController <ProjectsController>();
_imageService = new ImageService();
_projectsService = new ProjectsService(_projectsController, _imageService);
_customViewProjects = _projectsService.GetProjects();
ActivationChanged += OnActivationChanged;
}
public async Task DeleteProjectAsync_ShouldFail_IfProjectNotFound()
{
var service = new ProjectsService(Db, UserManager);
var result = await service.DeleteProjectAsync(0);
result.NotificationType.Should().Be(NotificationType.Error);
result.Message.Should().Be(ProjectsService.Message_Error_ProjectNotFound);
}
public async Task GetProjectAsync_ShouldSucceed()
{
var service = new ProjectsService(Db, UserManager);
var result = await service.GetProjectAsync <ProjectDetailsModel>(1);
result.NotificationType.Should().Be(NotificationType.Success);
AssertProjectModelProperties(result.Value);
}
internal void Initialize()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>().UseInMemoryDatabase(Guid.NewGuid().ToString());
this.dbContext = new ApplicationDbContext(options.Options);
this.projectsRepository = new EfDeletableEntityRepository <Project>(this.dbContext);
this.projectPicturesRepository = new EfDeletableEntityRepository <ProjectPicture>(this.dbContext);
this.service = new ProjectsService(this.projectsRepository, this.projectPicturesRepository);
}
private ProjectsService InitializeService(EfDeletableEntityRepository <Project> projectsRepository, ApplicationDbContext dbContext)
{
var projectCategoryRepository = new EfRepository <CategoryProject>(dbContext);
var projectOfferUserRepository = new EfRepository <ProjectOfferUser>(dbContext);
var service = new ProjectsService(projectsRepository);
return(service);
}
public async Task EditProjectAsync_ShouldFail_IfProjectNotFound()
{
var service = new ProjectsService(Db, UserManager);
var result = await service.EditProjectAsync(
new ProjectViewModel { Id = 0 }, CreateUserRoleClaimPrincipal("Admin"));
result.NotificationType.Should().Be(NotificationType.Error);
result.Message.Should().Be(ProjectsService.Message_Error_ProjectNotFound);
}
public CreateProjectViewModel()
{
_projectsService = DependencyService.Resolve <ProjectsService>();
_requestId = RequestIdProvider.GetRequestId();
CreateCommand = new AsyncCommand(CreateAsync);
BeginDate = DateTime.Now;
EndDate = BeginDate + TimeSpan.FromDays(30);
}
protected virtual void ConstructEndpoints()
{
this.AuthenticationService = new AuthenticationService(this);
this.projectsService = new ProjectsService(this);
this.ActivityService = new ActivityService(this);
this.TaskLogService = new TaskLogService(this);
this.Users = new UserEndpoint(this);
this.Projects = new ProjectEndpoint(this);
this.Tasks = new TaskEndpoint(this);
}
private static async Task GetProjectForEditingAsync_ShouldFail(int id, string error)
{
var service = new ProjectsService(Db, UserManager);
var result = await service.GetProjectForEditingAsync <ProjectViewModel>(
id, new ClaimsPrincipal());
result.NotificationType.Should().Be(NotificationType.Error);
result.Message.Should().Be(error);
}
public async Task EditProjectAsync_ShouldFail_UserIsNotAdminOrProjectLead()
{
var service = new ProjectsService(Db, UserManager);
var result = await service.EditProjectAsync(
new ProjectViewModel { Id = 1 }, new ClaimsPrincipal());
result.NotificationType.Should().Be(NotificationType.Error);
result.Message.Should().Be(ProjectsService.Message_Error_UserNotAdminOrProjectLead);
}
private GcStatusModel PostNewItemStatus(string gcItemId, string statusId, string projectId)
{
ItemsService.ChangeItemStatus(gcItemId, statusId);
var status = ProjectsService.GetSingleStatus(statusId, projectId);
var statusModel = new GcStatusModel {
Color = status.Data.Color, Name = status.Data.Name
};
return(statusModel);
}
private async Task RefreshProject()
{
if (_projectsService == null)
{
_projectsService = _connector.CreateProjectsService();
}
var projectsForCurrentUser = await _projectsService.GetAccessibleProjects();
_projects = projectsForCurrentUser.ToList();
}
/// <summary>
///
/// </summary>
/// <param name="items"></param>
/// <param name="statusId"></param>
/// <param name="projectId"></param>
private void PostNewStatusesForItems(List <MappingResultModel> items, string statusId, string projectId)
{
foreach (MappingResultModel item in items)
{
ItemsService.ChooseStatusForItem(item.GCItemId, statusId);
var status = ProjectsService.GetSingleStatus(statusId, projectId);
item.Status.Color = status.Data.Color;
item.Status.Name = status.Data.Name;
}
}
public async Task GetProjects_With_Authenticated_User()
{
// Arrange
//var token = await GetAuthenticationToken();
ProjectsService svc = new ProjectsService(await GetAuthenticationService());
// Act
var projects = await svc.GetProjects();
// Assert
Assert.IsNotNull(projects);
}
public ProjectInfoViewModel(IWindowManager windowManager, IUnitOfWork uow, int idProject, bool isAdd = true)
{
_windowManager = windowManager;
_uow = uow;
IsAddMode = isAdd;
var projectsService = new ProjectsService(uow);
var list = projectsService.GetAllUserForCurrentProject(idProject);
Workers = new ObservableCollection <UserDTO>(list);
}
private static async Task GetProjectForEditingAsync_ShouldSucceed(
ClaimsPrincipal claimsPrincipal)
{
var service = new ProjectsService(Db, UserManager);
var result = await service.GetProjectForEditingAsync <ProjectViewModel>(
1, claimsPrincipal);
result.NotificationType.Should().Be(NotificationType.Success);
AssertProjectModelProperties(result.Value);
}
public static IEnumerable <SelectListItem> GetProjects()
{
var service = new ProjectsService(
new DBManager(
DependencyResolver.Current.GetService <IDBRepository>()));
return(service.SelectProjects().Select(x => new SelectListItem
{
Text = x.ProjectName,
Value = x.ID.ToString()
}));
}
public void should_succeed_get_ById()
{
var pservice = new ProjectsService();
var pcontroller = new ProjectsController(pservice);
var res = pcontroller.GetProjects("5628f15462e7e026440c9482").Result;
var contentResult = res as OkNegotiatedContentResult<Projects>;
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(contentResult.Content.Id, new ObjectId("5628f15462e7e026440c9482"));
}
public void GetProjects()
{
ProjectsService service = new ProjectsService( API_KEY );
Project[] projects = service.GetProjects();
Assert.IsNotNull( projects, "we should have gotten some projects back" );
foreach( var item in projects )
{
Assert.IsNotNull( item.Name, "name should always come back" );
Assert.AreEqual( DateTime.MinValue, item.CreatedAt, "CreatedAt isn't populated by default" );
Assert.IsFalse( item.ModifiedAt.HasValue, "modified date is null" );
Assert.IsNull( item.Followers, "shouldn't be any followers" );
}
}
public void GetProjectsWithFields()
{
ProjectsService service = new ProjectsService( API_KEY );
Project[] projects = service.GetProjects( new OptionalFields[] { OptionalFields.Project_CreatedAt, OptionalFields.Project_ModifiedAt } );
Assert.IsNotNull( projects, "we should have gotten some projects back" );
foreach( var item in projects )
{
Assert.IsNotNull( item.Name, "name should always come back" );
Assert.AreNotEqual( DateTime.MinValue, item.CreatedAt, "CreatedAt should be populated" );
Assert.IsTrue( item.ModifiedAt.HasValue, "modified date shouldn't be null" );
Assert.IsNull( item.Followers, "shouldn't be any followers" );
}
}
public void should_succeed_if_projects_id_is_set_to_Mongodb_objectId()
{
var pservice = new ProjectsService();
var pcontroller = new ProjectsController(pservice);
pcontroller.Request = new HttpRequestMessage();
pcontroller.Configuration = new HttpConfiguration();
var p = new Projects
{
title= "eTimeSheet3",
code="ET3"
};
var res = pcontroller.PostProjects(p);
//Projects project;
//Assert.IsTrue(res.TryGetContentValue<Projects>(out project));
// Assert.AreEqual(project.Id , ! null);
}
public void should_succeed_Update()
{
var pservice = new ProjectsService();
var pcontroller = new ProjectsController(pservice);
var res =pcontroller.GetProjects("5628f15462e7e026440c9482").Result;
var contentResult = res as OkNegotiatedContentResult<Projects>;
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Projects project = contentResult.Content;
project.title = "TestProject";
var res1 = pcontroller.PutProjects("5628f15462e7e026440c9482", project).Result;
var contentResult1 = res as OkNegotiatedContentResult<Projects>;
Assert.IsNotNull(contentResult1);
Assert.IsNotNull(contentResult1.Content);
Assert.AreEqual(contentResult1.Content.title, "TestProject");
}
public ProjectsController()
{
this.projects = new ProjectsService();
}
public void should_succeed_Delete()
{
var pservice = new ProjectsService();
var pcontroller = new ProjectsController(pservice);
var res = pcontroller.DeleteProjects("5628f15462e7e026440c9482").Result;
var contentResult = res as OkNegotiatedContentResult<Projects>;
Assert.IsNotNull(contentResult);
}
public StatisticsController()
{
this.projects = new ProjectsService();
}
