public ActionResult Delete(string id)
{
var repo = new ProjectRepository();
repo.Delete(new ObjectId(id));
return JsonNet(new {success = true});
}
public void Init()
{
_taskRepository = new TaskRepository();
_console = new RealConsole();
_projectRepository = new ProjectRepository();
_taskCommandFactory = new TaskCommandFactory(_console, _projectRepository, _taskRepository);
}
public static int AskForTheProject()
{
var projects = new ProjectRepository().GetAll();
int newProjectId;
string newProjectName;
foreach (var project in projects)
{
if (project.id == 0)
{
newProjectId = 1;
newProjectName = projectName + newProjectId.ToString();
DateTime projectDeadLine = DateTime.Now;
new ProjectRepository().Add(new Project(newProjectId, projectName, DateTime.Now.Add(TimeSpan.Parse(periodOfExecution))));
return 1;
}
}
try
{
newProjectId = projects.Last().id + 1;
}
catch
{
newProjectId = 1;
newProjectName = projectName + newProjectId.ToString();
DateTime projectDeadLine = DateTime.Now;
new ProjectRepository().Add(new Project(newProjectId, projectName, DateTime.Now.Add(TimeSpan.Parse(periodOfExecution))));
return 1;
}
new ProjectRepository().Add(new Project(newProjectId, projectName, DateTime.Now.Add(TimeSpan.Parse(periodOfExecution))));
return newProjectId;
}
public void Init()
{
johnDoe = new Person { NickName = "JohnDoe", Password = "******" + DateTime.Now.Ticks.ToString(), PrimaryMail = "*****@*****.**", UserPhoto = null };
repository = new ProjectRepository();
stubProject = new Project { Name = "SuperDuper", Description = "Super-puper-giga-cool", License = "Beer license", SiteUrl = @"http://foo.site", Tags = "C Python HTML5 jQuery", TrackerUrl = @"http://tracker.foo.site" };
johnDoe.Projects = new HashSet<Project>();
johnDoe.Projects.Add(stubProject);
}
public DashboardViewModel()
{
_departmentRepository = new DepartmentRepository();
_employeeRepository = new EmployeeRepository();
_projectRepository = new ProjectRepository();
RefreshAll();
}
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 LoadAll()
{
var repo = new ProjectRepository();
var projects = repo.All().ToList();
projects.Should().NotBeNull();
}
public void LoadSummary()
{
var repo = new ProjectRepository();
var projects = repo.All().Where(p => p.Name.StartsWith("New")).Select(ProjectRepository.SelectSummary()).ToList();
projects.Should().NotBeNull();
}
public void notify_that_project_was_not_found_when_trying_to_add_an_task_to_nonexistent_project()
{
var projectRepository = new ProjectRepository();
projectRepository.Add(new Project("training"));
_addTaskCommand.Execute();
_console.Received().WriteLine("Could not find a project with the name \"{0}\".", "secrets");
}
public TaskCommandFactory(
IConsole console,
ProjectRepository projectRepository,
TaskRepository taskRepository)
{
_console = console;
_projectRepository = projectRepository;
_taskRepository = taskRepository;
}
public void TestGetMethod()
{
//
// Functional Test against Azure Emulator
//
var projectRepository = new ProjectRepository(CloudStorageAccount.DevelopmentStorageAccount,ProjectRepositoryTestConfig.StorageVersion);
Project project = projectRepository.Get(ProjectRepositoryTestConfig.UserName, ProjectRepositoryTestConfig.ProjectId);
}
public NewProjectViewModel()
{
_repository = new ProjectRepository();
Project = new Project();
MainProperties = new ProjectMainPropertiesViewModel(Project);
OkCommand = new Command(() => MainProperties.IsValid(), Save);
CancelCommand = new Command(() => DialogResult = false);
}
public ProjectListViewModel()
{
_repository = new ProjectRepository();
RefreshAll();
AddProjectCommand = new Command(AddProject);
EditProjectCommand = new Command<ProjectDto>(x => x != null, EditProject);
DeleteProjectCommand = new Command<ProjectDto>(x => x != null, DeleteProject);
}
public void AddAProjectToRepository()
{
var projectRepository = new ProjectRepository();
var project = new Project("secrets");
var addProjectCommand = new AddProjectCommand(projectRepository, "secrets");
addProjectCommand.Execute();
Assert.That(projectRepository.AllProjects()[0], Is.EqualTo(project));
}
public void GetAllNamesReturnsCorrectNames()
{
// Arrange
IProjectRepository repo = new ProjectRepository( Session );
// Act
string[] names = repo.GetAllNames().ToArray();
// Assert
CollectionAssert.AreEquivalent( TestData.Select( t => t.Name ).ToArray(), names );
}
public ProjectController(IUnitOfWork unitOfWork)
: base(unitOfWork)
{
_projectRepository = new ProjectRepository(unitOfWork);
_categoryRepostitory =new CategoryRepostitory(unitOfWork);
_tasklogRepository = new TasklogRepository(unitOfWork);
_documentRepository = new DocumentRepository(unitOfWork);
_fileStore = new DiskFileStore();
_feeRepository = new PaidFeeRepository(unitOfWork);
_userRepository = new UserRepository(unitOfWork);
}
public static int AskForTheProject()
{
ProjectRepository projectRepository = new ProjectRepository();
Project project = new Project();
project.name = projectName;
project.deadLine = DateTime.Now.Add(TimeSpan.Parse(periodOfExecution));
projectRepository.Add(project);
return projectRepository.GetAll().Last().id;
}
public SprintSelectorViewModel(Project project,
Func<Project,Sprint,ProjectDetailsViewModel> projectDetailsFactory,
ProjectRepository projectRepository,
IShell shell)
{
_project = project;
_projectDetailsFactory = projectDetailsFactory;
_projectRepository = projectRepository;
_shell = shell;
_projectRepository.GetSprintsObservable(_project).ToProperty(this, t => t.AllSprints, out allSprints);
}
public NewEmployeeProjectViewModel(Employee employee)
{
_repository = new ProjectRepository();
_employee = employee;
Projects = _repository.GetProjectDtoList()
.Where(x => !employee.Projects.Any(y => y.Id == x.Id))
.ToList();
OkCommand = new Command(IsValid, Save);
CancelCommand = new Command(() => DialogResult = false);
}
public UnitOfWork()
{
_context = new ApplicationDbContext();
Projects = new ProjectRepository(_context);
Practices = new PracticeRepository(_context);
Users = new UserRepository(_context);
PracticeUsers = new PracticeUserRepository(_context);
Features = new FeatureRepository(_context);
FeatureUsers = new FeatureUserRepository(_context);
Experiences = new ExperienceRepository(_context);
Communications = new CommunicationRespository(_context);
Countries = new CountryRepository(_context);
}
public ProjectSelectorViewModel(
ProjectRepository projectRepository,
Func<Project,SprintSelectorViewModel> sprintSelectorFactory,
IShell shell
)
{
_projectRepository = projectRepository;
_sprintSelectorFactory = sprintSelectorFactory;
_shell = shell;
_projectRepository.GetAllObservable().
ToProperty(this, t => t.AllProjects, out _allProjects);
}
public async Task<ActionResult> Create(string projectId)
{
if (!string.IsNullOrEmpty(projectId))
{
var projectRepo = new ProjectRepository();
var project = await projectRepo.Get(projectId);
if (project == null)
{
project = new Project();
}
return View(project);
}
return View(new Project());
}
public void ProjectToSummaryWithConfig()
{
var repo = new ProjectRepository();
repo.Should().NotBeNull();
var result = repo.All()
.ToDataResult<Project, ProjectSummary>(config => config
.Page(1)
.PageSize(5)
.Selector(ProjectRepository.SelectSummary())
);
result.Should().NotBeNull();
result.Data.Should().NotBeNull();
}
public ExistingProjectViewModel(Project project)
{
_repository = new ProjectRepository();
Project = project;
var mainProperties = new ProjectMainPropertiesViewModel(project);
Tabs = new List<ViewModel>
{
mainProperties,
new ProjectEmployeeListViewModel(project)
};
OkCommand = new Command(() => mainProperties.IsValid(), Save);
CancelCommand = new Command(() => DialogResult = false);
}
public async Task<ActionResult> BuildAndroid(Project project)
{
var projectRepo = new ProjectRepository();
var isNewProject = false;
if (project.Id.ToString().Trim() == "000000000000000000000000")
{
isNewProject = true;
project.DateCreated = Helper.SetDateForMongo(DateTime.Now);
project.User = User.Identity.Name;
await projectRepo.CreateSync(project);
}
var output = ProcessBuild(project, "android", User.Identity.Name);
return Json(new { success = true, projectId = project.Id.ToString(), isNew = isNewProject }, JsonRequestBehavior.AllowGet);
}
public void ProjectToSummaryNoSelector()
{
var repo = new ProjectRepository();
repo.Should().NotBeNull();
QueryResult<ProjectSummary> result;
Action act = () => result = repo.All()
.ToDataResult<Project, ProjectSummary>(config => config
.Page(1)
.PageSize(5)
);
act.ShouldThrow<ArgumentNullException>();
}
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();
}
static void ShowContracts()
{
var contracts = new ContractRepository().GetAll();
ProjectRepository projectRepository = new ProjectRepository();
Console.WriteLine("************************************");
//Console.CursorLeft = 0;
//Console.CursorTop = 0;
foreach (var contract in contracts)
{
Console.WriteLine("Contract №{0}", contract.id);
Console.WriteLine(" Client's name: {0}", new ClientRepository().GetItem(contract.clientId).name);
Console.WriteLine(" Builder's name: {0}", new BuilderRepository().GetItem(contract.builderId).name);
Console.WriteLine(" Agent's name: {0}", new AgentRepository().GetItem(contract.agentId).name);
Console.WriteLine(" Project's name: {0}", projectRepository.GetItem(contract.projectId).name);
Console.WriteLine(" Project's deadLine: {0}", projectRepository.GetItem(contract.projectId).deadLine);
}
Console.WriteLine(contracts.Count());
}
static void CheckContracts()
{
var projects = new ProjectRepository().GetAll();
ContractRepository contractRepository = new ContractRepository();
foreach (var project in projects)
{
if (project.id == 0)
return;
if (project.deadLine < DateTime.Now)
{
var contracts = contractRepository.GetAll().ToArray();
var variable = contracts.Where(contract => contract.project.id == project.id).First();
contractRepository.Delete(variable);
new ProjectRepository().Delete(project);
}
}
}
public void ProjectRepositoryTest()
{
ProjectRepository repository = new ProjectRepository();
DateTime time = DateTime.MinValue;
Project expectedProject = new Project(repository.GetAll().Count() + 1, "projectsomeproject", time);
repository.Add(expectedProject);
Project realProject = repository.GetItem(expectedProject.id);
Assert.AreEqual(expectedProject, realProject);
repository.Delete(expectedProject);
realProject = repository.GetItem(expectedProject.id);
Assert.AreEqual(null, realProject);
}
public void SaveProject(project project)
{
ProjectRepository.Save(project);
}
public async Task <ActionResult> Apis(int projectId)
{
var project = await ProjectRepository.GetProjectAsync(projectId);
return(View(new ApisIndexViewModel(project, CurrentUserId)));
}
public async Task <ActionResult> Setup(int projectid)
{
var project = await ProjectRepository.GetProjectForFinanceSetup(projectid);
return(View(new FinanceSetupViewModel(project, CurrentUserId)));
}
public ProjectController(ProjectRepository projectRepository)
{
ProjectRepository = projectRepository;
}
public RunBookService(ProjectDbContext dbContext)
{
Repository = new ProjectRepository <RunBook>(dbContext);
}
public ProjectController(ProjectRepository proj)
{
_projects = proj;
}
public ActionResult List()
{
var projects = ProjectRepository.GetAllProjects();
return(View(projects));
}
public ProjectController()
{
_repository = new ProjectRepository();
}
public OctopusRepository(IOctopusClient client, RepositoryScope repositoryScope = null)
{
#if FULL_FRAMEWORK
LocationChecker.CheckAssemblyLocation();
#endif
Client = client;
Scope = repositoryScope ?? RepositoryScope.Unspecified();
Accounts = new AccountRepository(this);
ActionTemplates = new ActionTemplateRepository(this);
Artifacts = new ArtifactRepository(this);
Backups = new BackupRepository(this);
Beta = new OctopusSpaceBetaRepository(this);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(this);
BuildInformationRepository = new BuildInformationRepository(this);
CertificateConfiguration = new CertificateConfigurationRepository(this);
Certificates = new CertificateRepository(this);
Channels = new ChannelRepository(this);
CommunityActionTemplates = new CommunityActionTemplateRepository(this);
Configuration = new ConfigurationRepository(this);
DashboardConfigurations = new DashboardConfigurationRepository(this);
Dashboards = new DashboardRepository(this);
Defects = new DefectsRepository(this);
DeploymentProcesses = new DeploymentProcessRepository(this);
DeploymentSettings = new DeploymentSettingsRepository(this);
Deployments = new DeploymentRepository(this);
Environments = new EnvironmentRepository(this);
Events = new EventRepository(this);
FeaturesConfiguration = new FeaturesConfigurationRepository(this);
Feeds = new FeedRepository(this);
Interruptions = new InterruptionRepository(this);
LibraryVariableSets = new LibraryVariableSetRepository(this);
Lifecycles = new LifecyclesRepository(this);
Licenses = new LicensesRepository(this);
MachinePolicies = new MachinePolicyRepository(this);
MachineRoles = new MachineRoleRepository(this);
Machines = new MachineRepository(this);
Migrations = new MigrationRepository(this);
OctopusServerNodes = new OctopusServerNodeRepository(this);
PerformanceConfiguration = new PerformanceConfigurationRepository(this);
PackageMetadataRepository = new PackageMetadataRepository(this);
ProjectGroups = new ProjectGroupRepository(this);
Projects = new ProjectRepository(this);
Runbooks = new RunbookRepository(this);
RunbookProcesses = new RunbookProcessRepository(this);
RunbookSnapshots = new RunbookSnapshotRepository(this);
RunbookRuns = new RunbookRunRepository(this);
ProjectTriggers = new ProjectTriggerRepository(this);
Proxies = new ProxyRepository(this);
Releases = new ReleaseRepository(this);
RetentionPolicies = new RetentionPolicyRepository(this);
Schedulers = new SchedulerRepository(this);
ServerStatus = new ServerStatusRepository(this);
Spaces = new SpaceRepository(this);
Subscriptions = new SubscriptionRepository(this);
TagSets = new TagSetRepository(this);
Tasks = new TaskRepository(this);
Teams = new TeamsRepository(this);
Tenants = new TenantRepository(this);
TenantVariables = new TenantVariablesRepository(this);
UserRoles = new UserRolesRepository(this);
Users = new UserRepository(this);
VariableSets = new VariableSetRepository(this);
Workers = new WorkerRepository(this);
WorkerPools = new WorkerPoolRepository(this);
ScopedUserRoles = new ScopedUserRoleRepository(this);
UserPermissions = new UserPermissionsRepository(this);
UserTeams = new UserTeamsRepository(this);
UserInvites = new UserInvitesRepository(this);
UpgradeConfiguration = new UpgradeConfigurationRepository(this);
loadRootResource = new Lazy <RootResource>(LoadRootDocumentInner, true);
loadSpaceRootResource = new Lazy <SpaceRootResource>(LoadSpaceRootDocumentInner, true);
}
public ProjectController(ProjectRepository projectRepository, EmployeeRepository employeeRepository)
{
_projectRepository = projectRepository;
_employeeRepository = employeeRepository;
}
public ActionResult Update(int id, string name, string outputdir, string outputfilename, string[] mylanguages)
{
ProjectRepository.Update(id, name, outputdir, outputfilename);
LanguageRepository.UpdateProjectLanguages(id, mylanguages);
return(Content(string.Format("updated: {0}", id)));
}
private void InitPorjects()
{
Projects = ProjectRepository.GetProjects();
}
public CreateProjectWork(ProjectRepository projectRepository, ProjectContract newData, int userId) : base(projectRepository.UnitOfWork)
{
m_projectRepository = projectRepository;
m_newData = newData;
m_userId = userId;
}
private async Task <int[]> GetChildrenGroupIds(int projectId, int characterGroupId)
{
var groups = await ProjectRepository.GetGroupAsync(projectId, characterGroupId);
return(groups.GetChildrenGroups().Select(g => g.CharacterGroupId).Union(characterGroupId).ToArray());
}
public WeatherForecastController(ILogger <WeatherForecastController> logger, ProjectDbContext context)
{
_logger = logger;
projectRepository = new ProjectRepository(context);
}
public ProjectsController(ProjectsDatabaseContext context, FileService fileService)
{
projectRepository = new ProjectRepository(context);
_fileService = fileService;
}
static void Main()
{
var dbGenerator = new DbGenerator();
var(typeLookup, entityUtils, connectionSettings, sqlExecutor) = dbGenerator.Generate();
Console.WriteLine("Db Generated!");
var organizationRepository = new OrganizationRepository(typeLookup, new PostgreSQLConstants <Organization>(entityUtils),
entityUtils, new PostgreSQLExpressionUtils(), sqlExecutor, new List <string>());
var projectRepository = new ProjectRepository(typeLookup, new PostgreSQLConstants <Project>(entityUtils),
entityUtils, new PostgreSQLExpressionUtils(), sqlExecutor, new List <string>());
#region initial example
var organization = new Organization
{
Name = "test",
Email = "*****@*****.**"
};
var orgId = organizationRepository.Insert(1, organization).Result;
Console.WriteLine("Organization inserted, " + orgId);
var project = new Project
{
Name = "test",
Description = "test description",
Cost = 1,
IsActive = false
};
var projectId = projectRepository.Insert(1, project).Result;
Console.WriteLine("Project inserted, " + projectId);
project.Name = "other test";
projectRepository.Update(1, project).Wait();
project.Name = "more other test";
projectRepository.Update(1, project).Wait();
var updatedProject = projectRepository.Select(x => x.Id == projectId).Result;
Console.WriteLine("Project name updated to " + updatedProject.Name);
Console.WriteLine("Project revisions;");
var projectRevisions = projectRepository.SelectRevisions(projectId).Result;
for (var i = 0; i < projectRevisions.Count; i++)
{
var projectRevision = projectRevisions[i];
Console.WriteLine(projectRevision.Revision + " - " + projectRevision.Entity.Name);
}
try
{
var transactionalExecutor = new PostgreSQLTransactionalExecutor(new NpgsqlConnection(PostgreSQLConnectionFactory.GetConnectionString(connectionSettings)));
var result = transactionalExecutor.ExecuteAsync <bool>(async cnn =>
{
organizationRepository.SetSqlExecutorForTransaction(cnn);
projectRepository.SetSqlExecutorForTransaction(cnn);
var orgIdOther = organizationRepository.Insert(1, organization).Result;
project.OrganizationId = orgIdOther;
project.OrganizationUid = organization.Uid;
project.OrganizationName = organization.Name;
var projectIdOther = await projectRepository.Insert(1, project);
return(true);
}).Result;
}
catch (Exception e)
{
Console.WriteLine(e);
}
Console.WriteLine("project count " + projectRepository.Count().Result);
Console.WriteLine("organization count " + organizationRepository.Count().Result);
#endregion
#region order by example
for (var i = 0; i < 10; i++)
{
var organizationForOrderBy = new Organization
{
Name = "test " + i + 1,
Email = "*****@*****.**" + (i - 10),
Description = "order by test"
};
organizationRepository.Insert(1, organizationForOrderBy).Wait();
}
var orderedItems = organizationRepository.SelectAll(x => x.Description == "order by test", false,
new List <OrderByInfo <Organization> > {
new OrderByInfo <Organization>(y => y.Email, false)
}).Result;
Console.WriteLine("email desc ordered, first item > " + orderedItems.First().Email);
orderedItems = organizationRepository.SelectAll(x => x.Description == "order by test", false,
new List <OrderByInfo <Organization> > {
new OrderByInfo <Organization>(y => y.Name),
new OrderByInfo <Organization>(y => y.Id, false),
}).Result;
Console.WriteLine("name asc ordered, first item > " + orderedItems.First().Name + " - " + orderedItems.First().Id);
#endregion
Console.Read();
}
public project GetProjectById(int id)
{
return(ProjectRepository.FindBy(p => p.project_id == id && p.status == 1).Include(p => p.project_content).Include(p => p.project_overview).Include(p => p.project_facility.Select(q => q.facility.facility_content)).FirstOrDefault());
}
public async Task <ActionResult> Setup(int projectId)
{
var project = await ProjectRepository.GetProjectAsync(projectId);
return(View(new CheckInSetupModel(project)));
}
public List <project> SearchProjectList(string search)
{
return(ProjectRepository.FindBy(p => p.status == 1 && p.type != 2 && (Equals(search, null) || p.project_content.Any(q => q.name.Contains(search)))).Include(p => p.project_content).ToList());
}
public NfrCommandHandler(NfrRepository nfrRepository, IIssueFactory issueFactory, ProjectRepository projectRepository, ILabelsSearcher labelsSearcher, IMembershipService authorizationService, UserRepository userRepository, ISprintSearcher sprintSearcher, CallContext callContext)
{
this.nfrRepository = nfrRepository;
this.issueFactory = issueFactory;
this.projectRepository = projectRepository;
this.labelsSearcher = labelsSearcher;
this.authorizationService = authorizationService;
this.userRepository = userRepository;
this.sprintSearcher = sprintSearcher;
this.callContext = callContext;
}
public project GetProjectByName(string name)
{
return(ProjectRepository.FindBy(p => p.project_content.Any(q => q.name.ToLower() == name.ToLower()))
.FirstOrDefault());
}
public ProjectCore(ProjectRepository ARepository)
{
Repository = ARepository;
}
public List <project> GetAllProject()
{
return(ProjectRepository.FindBy(p => p.status == 1 && p.type != 2).Include(p => p.project_content).ToList());
}
public ProjectService(IMapper mapper,
ProjectRepository projectRepository)
{
_mapper = mapper;
_projectRepository = projectRepository;
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Developers = new DeveloperRepository(_context);
Projects = new ProjectRepository(_context);
}
public ActionResult Delete(int id)
{
ProjectRepository.DeleteProject(id);
return(Content(string.Format("deleted - {0}", id)));
}
public async Task <ActionResult> AddRoomType(int projectId)
{
return(View(new RoomTypeViewModel(
await ProjectRepository.GetProjectAsync(projectId), CurrentUserId)));
}
public ProjectService()
{
_mr = new ProjectRepository();
}
public DisplayProjectService()
{
context = new PortalEntities();
db = new ProjectRepository(context);
}