public async Task <ListResponse <ProjectResponse> > RunAsync(ProjectFilter filter, ListOptions options)
{
//Mapper.Initialize(cfg => cfg.CreateMap<Project, ProjectResponse>()
// .ForMember("OpenTasksCount", otc => otc.MapFrom(src => src.Tasks.Count(t => t.Status != Entities.TaskStatus.Completed))));
IQueryable <ProjectResponse> query = _context.Projects
.Select(p => Mapper.Map <ProjectResponse>(p));
//{
// Id = p.Id,
// Name = p.Name,
// Description = p.Description,
// OpenTasksCount = p.Tasks.Count(t => t.Status != Entities.TaskStatus.Completed)
//}
query = ApplyFilter(query, filter);
int totalCount = await query.CountAsync();
if (options.Sort == null)
{
options.Sort = "Id";
}
query = options.ApplySort(query);
query = options.ApplyPaging(query);
return(new ListResponse <ProjectResponse>
{
Items = await query.ToListAsync(),
Page = options.Page,
PageSize = options.PageSize ?? totalCount,
Sort = options.Sort,
TotalItemsCount = totalCount
});
}
public async Task <ProjectResponse> GetGsProjects(ProjectFilter projectFilter)
{
try
{
using (var httpClient = new HttpClient())
{
var queryString = ApiUrl.GetQuerryString(projectFilter);
var request = new HttpRequestMessage(HttpMethod.Get, new Uri(queryString));
ApiUrl.AddRequestHeaders(httpClient, request);
var responseMessage = await httpClient.SendAsync(request);
var projectsResponse = await responseMessage.Content.ReadAsStringAsync();
if (responseMessage.StatusCode == HttpStatusCode.OK)
{
return(JsonConvert.DeserializeObject <ProjectResponse>(projectsResponse));
}
}
}
catch (Exception e)
{
Log.Logger.Error($"GetGsProjects service method: {e.Message}\n {e.StackTrace}");
}
return(new ProjectResponse());
}
/// <summary>
/// A collection of Projects Targeted by this Goal
/// </summary>
public ICollection <Project> GetTargetedBy(ProjectFilter filter)
{
filter = filter ?? new ProjectFilter();
filter.Targets.Clear();
filter.Targets.Add(this);
return(Instance.Get.Projects(filter));
}
public async Task <ListResponse <ProjectResponse> > RunAsync(ProjectFilter filter, ListOptions options)
{
IQueryable <ProjectResponse> query = Context.Set <Project>()
.Select(p => new ProjectResponse
{
Id = p.Id,
Name = p.Name,
Description = p.Description,
OpenTasksCount = p.Tasks.Count(t => t.Status != Entities.TaskStatus.Completed)
});
query = ApplyFilter(query, filter);
int totalCount = await query.CountAsync();
if (options.Sort == null)
{
options.Sort = "Id";
}
query = options.ApplySort(query);
query = options.ApplyPaging(query);
return(new ListResponse <ProjectResponse>
{
Items = await query.ToListAsync(),
Page = options.Page,
PageSize = options.PageSize ?? totalCount,
Sort = options.Sort,
TotalItemsCount = totalCount
});
}
public IEnumerable <Project> Find(ProjectFilter filter)
{
IQueryable <Project> query = _dbContext.Project;
if (filter.Ids.Any())
{
query = query.Where(o => filter.Ids.Contains(o.Id));
}
if (!string.IsNullOrEmpty(filter.projectName))
{
query = query.Where(o => o.projectName.Contains(filter.projectName));
}
if (!string.IsNullOrEmpty(filter.workType))
{
query = query.Where(o => o.workType.Contains(filter.workType));
}
if (!string.IsNullOrEmpty(filter.contract))
{
query = query.Where(o => o.contract.Contains(filter.contract));
}
if (filter.SortByprojectName.HasValue && filter.SortByprojectName.Value == SortBy.ASC)
{
query = query.OrderBy(o => o.projectName);
}
if (filter.SortByprojectName.HasValue && filter.SortByprojectName.Value == SortBy.DESC)
{
query = query.OrderByDescending(o => o.projectName);
}
return(query.ToList());
}
public void ExportProjects_ExcelX_Success(ProjectFilter filter)
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <ProjectController>(Permissions.PropertyView);
var headers = helper.GetService <Mock <Microsoft.AspNetCore.Http.IHeaderDictionary> >();
headers.Setup(m => m["Accept"]).Returns(ContentTypes.CONTENT_TYPE_EXCELX);
var agency = EntityHelper.CreateAgency(1);
var project = new Entity.Project()
{
Agency = agency
};
var projects = new[] { project };
var service = helper.GetService <Mock <IPimsService> >();
var mapper = helper.GetService <IMapper>();
var page = new Paged <Entity.Project>(projects, filter.Page, filter.Quantity);
service.Setup(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>())).Returns(page);
// Act
var result = controller.ExportProjects(filter);
// Assert
var actionResult = Assert.IsType <FileStreamResult>(result);
Assert.Equal(ContentTypes.CONTENT_TYPE_EXCELX, actionResult.ContentType);
Assert.NotNull(actionResult.FileDownloadName);
Assert.True(actionResult.FileStream.Length > 0);
service.Verify(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>()), Times.Once());
}
public async Task <IEnumerable <ProjectDto> > GetProjects(ProjectFilter filter)
{
filter = filter ?? new ProjectFilter();
var projects = await(from proj in context.Projects
join pe in context.ProjectEmployees on proj.Id equals pe.ProjectId
into temp from pe in temp.DefaultIfEmpty()
where (filter.Name == null || proj.Name == filter.Name) &&
(filter.BeginDate == null || proj.BeginDate >= filter.BeginDate) &&
(filter.EndDate == null || proj.EndDate <= filter.EndDate) &&
(filter.Supervisor == null || proj.Supervisor.Id == filter.Supervisor) &&
(filter.Executor == null || pe.EmployeeId == filter.Executor)
select new ProjectDto
{
Id = proj.Id,
Name = proj.Name,
CustomerCompany = proj.CustomerCompany,
ExecutorCompany = proj.ExecutorCompany,
BeginDate = proj.BeginDate,
EndDate = proj.EndDate,
Supervisor = $"{proj.Supervisor.LastName} {proj.Supervisor.FirstName} {proj.Supervisor.Patronymic}",
Priority = proj.Priority,
Executors = string.Join(", ", (from emp in context.Employees
join projEmp in context.ProjectEmployees on emp.Id equals projEmp.EmployeeId
where projEmp.ProjectId == proj.Id
select $"{emp.LastName} {emp.FirstName} {emp.Patronymic}").ToArray())
}).Distinct().ToListAsync();
return(projects);
}
public ServiceCollectionResult <Project> GetProjectsPaged(string userId, ProjectFilter filter = ProjectFilter.All,
int page = 1, int pageSize = 10)
{
var result = new ServiceCollectionResult <Project>();
if (!Inspector.IsValidPageSize(pageSize))
{
result.HandleError(ErrorMessagesDict.InvalidPageSize);
return(result);
}
IEnumerable <Project> targetProjects;
if (filter != ProjectFilter.All)
{
if (filter == ProjectFilter.CreatedByMe)
{
targetProjects = GetProjectsUserCreated(userId);
}
else
{
targetProjects = GetProjectsUserInvolvedOnly(userId);
}
}
else
{
targetProjects = _accessService.GetAccessibleProjects(userId);
}
result.TargetCollection = targetProjects
.Skip((page - 1) * pageSize)
.Take(pageSize);
return(result);
}
public async Task <IActionResult> Index(ProjectFilter filter)
{
string ownerId = User.Claims.SingleOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value;
if (filter == null)
{
filter = new ProjectFilter {
OwnerId = ownerId
};
}
else
{
filter.OwnerId = ownerId;
}
var list = _service.Get(filter).ToList();
var listViewModel = new List <ProjectViewModel>();
foreach (var item in list)
{
listViewModel.Add(await MapToViewModel(item));
}
return(View(listViewModel));
}
public async Task <ListResponse <ProjectResponse> > RunAsync(ProjectFilter filter, ListOptions options)
{
var q = _uow.Projects.Query(t => t.Tasks, t => t.User);
await _factory.CreateAsyncQueryable(q).LoadAsync();
var query = q.ProjectTo <ProjectResponse>();
query = ApplyFilter(query, filter);
int totalCount = await _factory.CreateAsyncQueryable(query).CountAsync();
if (options.Sort == null)
{
options.Sort = "Id";
}
query = options.ApplySort(query);
query = options.ApplyPaging(query);
return(new ListResponse <ProjectResponse>
{
Items = await _factory.CreateAsyncQueryable(query).ToListAsync(),
Page = options.Page,
PageSize = options.PageSize ?? totalCount,
Sort = options.Sort,
TotalItemsCount = totalCount
});
}
public void ExportProjects_Csv_Success(ProjectFilter filter)
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <ProjectController>(Permissions.PropertyView);
var headers = helper.GetService <Mock <Microsoft.AspNetCore.Http.IHeaderDictionary> >();
headers.Setup(m => m["Accept"]).Returns(ContentTypes.CONTENT_TYPE_CSV);
var agency = EntityHelper.CreateAgency(1);
var project = new Entity.Project()
{
Agency = agency, ActualFiscalYear = 2021, ReportedFiscalYear = 2021
};
var projects = new[] { project };
var service = helper.GetService <Mock <IPimsService> >();
var mapper = helper.GetService <IMapper>();
var page = new Entity.Models.Paged <Entity.Project>(projects, filter.Page, filter.Quantity);
service.Setup(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>())).Returns(page);
// Act
var result = controller.ExportProjects(filter);
// Assert
var actionResult = Assert.IsType <ContentResult>(result);
var actualResult = Assert.IsType <string>(actionResult.Content);
Assert.Equal(ContentTypes.CONTENT_TYPE_CSV, actionResult.ContentType);
service.Verify(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>()), Times.Once());
}
/// <summary>
/// Projects associated with this TestSuite.
/// </summary>
public ICollection <Project> GetProjects(ProjectFilter filter)
{
filter = filter ?? new ProjectFilter();
filter.TestSuite.Clear();
filter.TestSuite.Add(this);
return(Instance.Get.Projects(filter));
}
protected IQuery <ProjectDTO> CreateQuery(ProjectFilter filter = null)
{
var query = ProjectListQuery;
query.Filter = filter;
return(query);
}
public ActionResult GetProjects(string environmentName, bool onlyDeployable)
{
var projectFilter =
new ProjectFilter
{
EnvironmentName = environmentName,
};
if (onlyDeployable && !_deployableEnvironments.Any(reg => Regex.IsMatch(environmentName, reg, RegexOptions.IgnoreCase)))
{
return(Json(null, JsonRequestBehavior.AllowGet));
}
var projectInfos = _agentService.GetProjectInfos(projectFilter);
List <ProjectViewModel> projectViewModels =
projectInfos
.Where(x => !onlyDeployable || x.AllowedEnvironmentNames.Contains(environmentName))
.Select(CreateProjectViewModel)
.ToList();
return
(Json(
new { projects = projectViewModels },
JsonRequestBehavior.AllowGet));
}
public SearchResult <ProjectObj> Search(string query, int curPage, int pageSize)
{
var splitQuery = query.Split(' ');
var filter = new ProjectFilter
{
QueryNames = splitQuery,
QueryDescriptions = splitQuery,
StartIndex = curPage * pageSize,
MaxResults = pageSize + 1 //we do +1 so we can see if the next button will be enabled
};
var objs = Repository.GetProjects(filter);
SearchResult <ProjectObj> result = new SearchResult <ProjectObj>();
result.HasMore = objs.Count > pageSize;
if (result.HasMore)
{
//we remove the last object because it was only fetched to see if has more is enabled
objs.RemoveAt(objs.Count - 1);
}
result.HasPrevious = curPage > 0;
result.Results = objs;
return(result);
}
public List <ProjectDTO> GetProjects(ProjectFilter filter)
{
using (var unitOfWork = UnitOfWorkProvider.Create())
{
return(CreateQuery(filter).Execute().ToList());
}
}
public void FindInDefautFields()
{
var projectFilter = new ProjectFilter();
projectFilter.Find.SearchString = "System";
Assert.AreEqual(1, Instance.Get.Projects(projectFilter).Count);
}
public void GetProjectsPage_Success(ProjectFilter filter)
{
// Arrange
var helper = new TestHelper();
var controller = helper.CreateController <SearchController>(Permissions.ProjectView);
var projects = EntityHelper.CreateProjects(1, 20);
var parcels = EntityHelper.CreateParcels(1, 2);
var buildings1 = EntityHelper.CreateBuildings(parcels.Next(0), 1, 5);
var buildings2 = EntityHelper.CreateBuildings(parcels.Next(1), 6, 5);
projects.Next(0).AddProperty(parcels.Next(0));
projects.Next(0).AddProperty(buildings1.ToArray());
projects.Next(1).AddProperty(parcels.Next(1));
projects.Next(1).AddProperty(buildings2.ToArray());
var service = helper.GetService <Mock <IPimsService> >();
var mapper = helper.GetService <IMapper>();
var page = new Entity.Models.Paged <Entity.Project>(projects, filter.Page, filter.Quantity);
service.Setup(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>())).Returns(page);
// Act
var result = controller.GetProjectsPage(filter);
// Assert
var actionResult = Assert.IsType <JsonResult>(result);
var actualResult = Assert.IsType <Api.Models.PageModel <ProjectModel> >(actionResult.Value);
var expectedResult = mapper.Map <ProjectModel[]>(projects);
Assert.Equal(expectedResult, actualResult.Items.ToArray(), new ShallowPropertyCompare());
service.Verify(m => m.Project.GetPage(It.IsAny <Entity.Models.ProjectFilter>()), Times.Once());
}
public async Task <IActionResult> FilterProjects(ProjectFilter model)
{
var projects = await projectService.GetProjects(model);
ViewBag.Employees = employeeService.GetEmployees().Select(x => new SelectListItem($"{x.LastName} {x.FirstName} {x.Patronymic}", x.Id.ToString()));
ViewBag.FilterModel = model;
return(View(nameof(Index), projects));
}
public async Task <IEnumerable <Project> > Get(ProjectFilter filter)
{
using (var ctx = GetContext()) {
var projects = await Filter(ctx, filter).ToListAsync();
return(projects.ToModel());
}
}
public IList <ProjectObj> GetByOwner(string username)
{
var filter = new ProjectFilter()
{
OwnersUserName = username
};
return(Repository.GetProjects(filter));
}
private OmProject GetOmProject(string name, string token)
{
var filter = new ProjectFilter();
filter.Name.Add(name);
var projects = instance.Get.Projects(filter);
return(projects.FirstOrDefault(item => item.ID.Token.Equals(token)));
}
/// <summary>
/// Search for projects based on given filter.
/// </summary>
/// <param name="filter"></param>
/// <returns>A task of a list of projects.</returns>
public Task <List <Project> > SearchProjectsAsync(ProjectFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
var q = EntitySet
.AsNoTracking();
//Name
if (!string.IsNullOrEmpty(filter.Name))
{
q = q.Where(x => x.Name.Contains(filter.Name));
}
//City
if (!string.IsNullOrEmpty(filter.City))
{
q = q.Where(x => x.City.Contains(filter.City));
}
//StartDate
if (filter.StartDate.HasValue)
{
q = q.Where(x => x.ParticipationStartDate >= filter.StartDate.Value);
}
//EndDate
if (filter.EndDate.HasValue)
{
q = q.Where(x => x.ParticipationEndDate >= filter.EndDate.Value || x.ParticipationEndDate == null);
}
//Closed
if (filter.Closed.HasValue)
{
q = q.Where(x => x.Closed == filter.Closed.Value);
}
q = filter.SetFilter(q);
filter.TotalItemCount = q.Count();
Task <List <Project> > projects;
if (filter.Offset >= 0 && filter.PageSize != 0)
{
projects = q.Skip(filter.Offset).Take(filter.PageSize).ToListAsync();
}
else
{
projects = q.ToListAsync();
}
return(projects);
}
/// <summary>
/// To get new project list after applying filter.
/// TODO: ProjectFilter
/// </summary>
/// <param name="filter"></param>
/// <param name="projects"></param>
/// <returns>Filtered project list.</returns>
public IEnumerable <IProject> FilterProjects(ProjectFilter filter, IEnumerable <IProject> projects)
{
if (String.IsNullOrWhiteSpace(filter.path))
{
return(projects);
}
return(projects?.Where(p => p.ProjectPath.IndexOf(filter.path, StringComparison.OrdinalIgnoreCase) != -1));
}
private static void RecurseProjects(PrimaryWorkitemFilter filter, IEnumerable <Project> projects)
{
foreach (Project project in projects)
{
filter.Project.Add(project);
var pfilter = new ProjectFilter();
pfilter.State.Add(State.Active);
RecurseProjects(filter, project.GetChildProjects(pfilter));
}
}
public List <Project> SelectProjects(ProjectFilter filter, PagingOption option)
{
var list = _dal.ProjectRepository.SelectProjects(filter, option);
foreach (Project item in list)
{
FillReferenceProperties(item);
}
return(list);
}
public ActionResult Filters(ProjectFilter filter)//Метод для фильтрации информации о проектах
{
using (context = new DataContext())
{
var result = context.Project.ToList().Join(context.Employee, a => a.ManagerId, b => b.Id, (p, c) => new ProjectView// соединение таблиц Project и Employee и выборка для представления
{
Id = p.Id,
Name = p.Name,
Customer = p.Customer,
Executor = p.Executor,
Manager = c.Name + " " + c.Surname + " " + c.Middle_name,
Date_start = p.Date_start.ToShortDateString(),
Date_end = p.Date_end.ToShortDateString(),
Priority = p.Priority
});
//передача данных в представление
ViewBag.Names = result.Select(a => a.Name).Distinct().ToList();
ViewBag.Customers = result.Select(a => a.Customer).Distinct().ToList();
ViewBag.Executors = result.Select(a => a.Executor).Distinct().ToList();
ViewBag.Managers = result.Select(a => a.Manager).Distinct().ToList();
ViewBag.Priorities = result.Select(a => a.Priority).Distinct().ToList();
//Фильтрация результата через набор условий
result = result.Where(a => Convert.ToDateTime(a.Date_start) > filter.start && Convert.ToDateTime(a.Date_start) < filter.end); //фильтр даты
if (filter.name != "All") //задано ли условие с именем проекта
{
result = result.Where(a => a.Name.Contains(filter.name));
}
if (filter.customer != "All")//задано ли условие с заказчиком
{
result = result.Where(a => a.Customer.Contains(filter.customer));
}
if (filter.executor != "All")//задано ли условие с исполнителем
{
result = result.Where(a => a.Executor.Contains(filter.executor));
}
if (filter.manager != "All")//задано ли условие с руководителем
{
result = result.Where(a => a.Manager.Contains(filter.manager));
}
if (filter.priority != -1)//задано ли условие с приоритетом
{
result = result.Where(a => a.Priority == filter.priority);
}
//передача результата в представление
ViewBag.Projects = result.ToList();
}
return(View("Projects"));
}
private static void RecurseProjects(TreeNodeCollection nodes, IEnumerable <Project> projects)
{
foreach (Project project in projects)
{
TreeNode node = nodes.Add(project.Name);
node.Tag = project.ID;
var filter = new ProjectFilter();
filter.State.Add(State.Active);
RecurseProjects(node.Nodes, project.GetChildProjects(filter));
}
}
public FilterResult <Project> Query(FilterState filterState)
{
var result = new FilterResult <Project>();
IQueryable <Project> query = Context.Projects;
if (filterState != null)
{
// Filtering
if (filterState.Filter?.Filters != null)
{
var filter = new ProjectFilter();
if (filterState.Filter.Logic.ToLower() == "and")
{
filter.CompositeFilter(filterState.Filter, ref query);
}
else
{
throw new NotImplementedException("Logic not handled");
}
}
// Sorting
if (filterState.Sort != null)
{
foreach (var sort in filterState.Sort)
{
var purchaseOrderSort = new ProjectSort();
purchaseOrderSort.Sort(sort, ref query);
}
}
if (filterState.Take > 0)
{
// Pagination
result.Data = query
.Skip(filterState.Skip)
.Take(filterState.Take)
.ToList();
}
else
{
result.Data = query.ToList();
}
}
else
{
result.Data = query.ToList();
}
// Get total records count
result.Total = query.Count();
return(result);
}
public ActionResult Projects(ProjectFilter filter)
{
var model = new ProjectsViewModel
{
Filter = filter,
ServicedApplicationCategories = bll.ProjectManager.SelectServicedApplicationCategories(),
ServicedIndustries = bll.ProjectManager.SelectServicedIndustries()
};
return(View(model));
}
public void TestShouldRunIntegrationAllowedByExclusionFilter()
{
ProjectForceFilter TestSubject = new ProjectForceFilter();
TestSubject.ProjectFilters = new ProjectFilterList();
ProjectFilter Project = new ProjectFilter();
Project.Project = "TestProject";
Project.ServerUri = "TestUri";
Project.ExclusionFilters.Activities = new ProjectActivity[2] { ProjectActivity.Building, ProjectActivity.CheckingModifications };
Project.ExclusionFilters.Conditions = new IntegrationStatus[1] { IntegrationStatus.Failure };
RecorderIRemotingService RemotingRecorder = new RecorderIRemotingService();
RecorderICruiseManager CruiseRecorder = new RecorderICruiseManager();
ProjectStatus Stati = new ProjectStatus();
Stati.Name = "TestProject";
Stati.Activity = ProjectActivity.Sleeping;
Stati.BuildStatus = IntegrationStatus.Success;
CruiseRecorder.Recordings.GetProjectStatusRecording.ReturnValue = new ProjectStatus[1] { Stati };
RemotingRecorder.Recordings.ConnectTypeStringRecording.ReturnValue = CruiseRecorder;
Project.RemoteService = RemotingRecorder;
TestSubject.ProjectFilters.Add(Project);
bool Condition = TestSubject.ShouldRunIntegration(null, null);
Assert.IsTrue(RemotingRecorder.Recordings.ConnectTypeStringRecording.Called);
Assert.AreEqual("TestUri", RemotingRecorder.Recordings.ConnectTypeStringRecording.PassedStringuri);
Assert.AreEqual(typeof(ICruiseManager), RemotingRecorder.Recordings.ConnectTypeStringRecording.PassedTypeproxyType);
Assert.IsTrue(CruiseRecorder.Recordings.GetProjectStatusRecording.Called);
Assert.IsTrue(Condition);
}
private void newTemplate(ProjectFilter parent, String name)
{
ObjectBuilder newTemplate = Templates.newTemplate(name);
if (CurrentProject != null)
{
CurrentProject.addTemplateToProject(name, parent);
saveTemplate(newTemplate, true);
}
MainWindow mw = MainWindow as MainWindow;
if (mw != null)
{
mw.TemplateTab.SelectedIndex = m_templates.Templates.Count - 1;
selectObjectBuilder(mw.TemplateTab.SelectedIndex);
}
}
public void newTemplate(ProjectFilter parent)
{
StringQueryItem qry = new StringQueryItem("Enter new template name", "New Template", "New");
StringQuery q = new StringQuery();
q.DataContext = qry;
bool? result = q.ShowDialog();
if (result.Value)
{
newTemplate(parent, qry.Text);
}
}
public virtual ActionResult List(bool showCustomer = false, ProjectFilter projectFilter = null)
{
projectFilter = projectFilter ?? new ProjectFilter();
var model = new ProjectsListViewModel()
{
ShowCustomer = showCustomer,
Projects = ProjectService.GetAll(Query.ForProject(projectFilter).Include(x => x.Customer()))
};
return View(model);
}
public void TestShouldRunIntegrationBlockedByInclusionFilterCauseFailed()
{
ProjectTriggerFilter TestSubject = new ProjectTriggerFilter();
RecorderITrigger TriggerRecorder = new RecorderITrigger();
TriggerRecorder.Recordings.ShouldRunIntegrationRecording.ReturnValue = BuildCondition.IfModificationExists;
TestSubject.InnerTrigger = TriggerRecorder;
TestSubject.ProjectFilters = new ProjectFilterList();
ProjectFilter Project = new ProjectFilter();
Project.Project = "TestProject";
Project.ServerUri = "TestUri";
Project.InclusionFilters.Activities = new ProjectActivity[1] { ProjectActivity.Sleeping };
Project.InclusionFilters.Conditions = new IntegrationStatus[1] { IntegrationStatus.Success };
RecorderIRemotingService RemotingRecorder = new RecorderIRemotingService();
RecorderICruiseManager CruiseRecorder = new RecorderICruiseManager();
ProjectStatus Stati = new ProjectStatus();
Stati.Name = "TestProject";
Stati.Activity = ProjectActivity.Sleeping;
Stati.BuildStatus = IntegrationStatus.Failure;
CruiseRecorder.Recordings.GetProjectStatusRecording.ReturnValue = new ProjectStatus[1] { Stati };
RemotingRecorder.Recordings.ConnectTypeStringRecording.ReturnValue = CruiseRecorder;
Project.RemoteService = RemotingRecorder;
TestSubject.ProjectFilters.Add(Project);
BuildCondition Condition = TestSubject.ShouldRunIntegration();
Assert.IsTrue(RemotingRecorder.Recordings.ConnectTypeStringRecording.Called);
Assert.AreEqual("TestUri", RemotingRecorder.Recordings.ConnectTypeStringRecording.PassedStringuri);
Assert.AreEqual(typeof(ICruiseManager), RemotingRecorder.Recordings.ConnectTypeStringRecording.PassedTypeproxyType);
Assert.IsTrue(CruiseRecorder.Recordings.GetProjectStatusRecording.Called);
Assert.AreEqual(BuildCondition.NoBuild, Condition);
}
protected void InitView()
{
if (String.Compare(Request["view"], "all", true) == 0)
ShowClosedProjects = true;
var list = RecieveData();
if (list.Count == 0 && CurrentFilter == ProjectFilter.Default)
{
CurrentFilter = ProjectFilter.All;
list = RecieveData();
}
string caption = String.Empty;
switch (CurrentFilter)
{
case ASC.Web.Projects.Controls.Projects.ListProjectView.ProjectFilter.My:
case ASC.Web.Projects.Controls.Projects.ListProjectView.ProjectFilter.Default:
caption = ProjectResource.MyProjects;
break;
case ASC.Web.Projects.Controls.Projects.ListProjectView.ProjectFilter.All:
caption = ProjectResource.AllProjects;
break;
case ASC.Web.Projects.Controls.Projects.ListProjectView.ProjectFilter.Following:
caption = ProjectResource.ProjectsKeepTrack;
break;
case ASC.Web.Projects.Controls.Projects.ListProjectView.ProjectFilter.ByLabel:
caption = UrlParameters.ProjectsTag;
break;
}
(Page.Master as ASC.Web.Projects.Masters.BasicTemplate).BreadCrumbs.Add(new BreadCrumb { Caption = caption });
InitControls();
_rptContent.DataSource = GetRepeaterDataSourceList(list);
_rptContent.DataBind();
}
