public async Task Should_Throw_ProjectShortNameAlready_Exception_For_Duplicate_ShortName()
{
var createProjectDto = new CreateProjectDto
{
Name = "ABP vNext",
ShortName = "ABP",
Format = "md",
DefaultDocumentName = "index",
NavigationDocumentName = "docs-nav.json",
ParametersDocumentName = "docs-params.json",
MinimumVersion = "1",
MainWebsiteUrl = "abp.io",
LatestVersionBranchName = "",
DocumentStoreType = "GitHub",
ExtraProperties = new Dictionary <string, object>()
};
createProjectDto.ExtraProperties.Add("GitHubRootUrl",
"https://github.com/abpframework/abp/tree/{version}/docs/en/");
createProjectDto.ExtraProperties.Add("GitHubAccessToken", "123456");
createProjectDto.ExtraProperties.Add("GitHubUserAgent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64)");
//Act
await Assert.ThrowsAsync <ProjectShortNameAlreadyExistsException>(() =>
_projectAdminAppService.CreateAsync(createProjectDto));
}
public IActionResult Create(CreateProjectDto CreateProjectDto)
{
var UID = User.FindFirst(ClaimTypes.NameIdentifier).Value;
projectManagerRepository.AddProject(CreateProjectDto);
return(RedirectToAction("ShowProjects", "ProjectManager", UID));
}
public IActionResult CreateProject(Guid freelancerId, [FromBody] CreateProjectDto model)
{
if (ModelState.IsValid)
{
var userId = new Guid(this.User.FindFirstValue(ClaimTypes.NameIdentifier));
if (freelancerId == userId)
{
var projectRep = _WorkRepository.CreateProject(freelancerId, model.Title);
if (!projectRep.Any())
{
return(NotFound());
}
var projects = projectRep.Select(a => new ProjectDto
{
ProjetId = a.Id,
Title = a.Title,
startDate = a.StartDate
});
return(Ok(projects));
}
}
return(BadRequest());
}
public async Task <IActionResult> Create([FromBody] CreateProjectDto projectDto)
{
if (projectDto == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var mapped = Mapper.Map <Projects>(projectDto);
await _project.Create(projectDto);
//
if (!await _project.Save())
{
return(StatusCode(500, "Server Error, Something went wrong with our server"));
}
var created = Mapper.Map <Projects>(mapped);
return(CreatedAtRoute("GetProject", new { id = created.Id }, created));
}
else
{
return(BadRequest(ModelState));
}
}
public int CreateProject(CreateProjectDto input)
{
Logger.Info("Creating a project for input: " + input);
var project = new Project
{
TenantId = _abpSession.TenantId,
Name = input.Name,
Description = input.Description,
StartTime = input.StartTime,
DeliverTime = input.DeliverTime,
TeamLeaderId = input.TeamLeaderId
};
if (input.TeamLeaderId.HasValue)
{
var user = _userRepository.Get(ObjectMapper.Map <long>(input.TeamLeaderId));
project.TeamLeader = user;
string message = "A new project -- \"" + input.Name + "\" has being assigned to u.";
_notificationPublisher.Publish("New Project", new MessageNotificationData(message), null, NotificationSeverity.Info, new[] { user.ToUserIdentifier() });
}
return(_projectRepository.InsertAndGetId(project));
}
public async Task <IActionResult> Create([FromBody] CreateProjectDto project)
{
Guard.IsNotNull(project, nameof(project));
if (!ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
project.CreatedBy = this.username;
var p = new Project
{
ProjectId = Guid.NewGuid(),
EndDate = project.EndDate,
ProjectName = project.ProjectName,
StartDate = project.StartDate
};
var result = await this.mediator.Send(Project.CreateProjectCreatedEventArgs(p));
if (result.Outcome == OutcomeType.Successful)
{
var url = this.linkGenerator.GetPathByAction(
this.HttpContext,
controller: "Projects",
action: "GetById",
values: new { id = p.ProjectId });
return(this.Created($"{this.HttpContext.Request.Scheme}//{this.HttpContext.Request.Host}{url}", this.mapper.Map <Project>(p)));
}
return(new StatusCodeResult(500));
}
public async Task <IActionResult> CreateProject([FromBody] CreateProjectDto project)
{
if (project == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var projectToCreate = Mapper.Map <Project>(project);
_projectManagerRepository.AddProjectAsync(projectToCreate);
if (!await _projectManagerRepository.SaveAsync())
{
_logger.LogError("An error occured creating the new project");
return(StatusCode(500, "A problem happened while handling your request."));
}
var createdProjectToReturn = Mapper.Map <ProjectDto>(projectToCreate);
return(CreatedAtRoute("GetProject", new
{
id = createdProjectToReturn.Id,
},
createdProjectToReturn));
}
public virtual async Task <ProjectDto> CreateAsync(CreateProjectDto input)
{
return(await RequestAsync <ProjectDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
{
{ typeof(CreateProjectDto), input }
}));
}
public async Task <ActionResult <Project> > Create(CreateProjectDto project)
{
var createdProject = await _projectService.AddAsync(_mapper.Map <Project>(project));
return(CreatedAtAction(nameof(GetByIdAndCode), new { id = createdProject.Id, code = createdProject.Code },
createdProject));
}
public async Task <IActionResult> Create([FromBody] CreateProjectDto projectDto)
{
var currentUserId = _httpContextAccessor.GetCurrentUserId();
var currentUser = _userService.Read(currentUserId);
var project = _projectService.CreateProject(currentUser, projectDto.Title, projectDto.Content);
if (project == null)
{
return(BadRequest(new { Message = "Failed to create project." }));
}
var createdProjectDto = _mapper.Map <CreateProjectDto>(project);
createdProjectDto.ProjectOwner = _mapper.Map <ReadUserDto>(project.User);
try
{
// Notify all subscribers (logged in users) that a new project has been created.
await _projectHubContext.Clients
.Groups(Constants.ProjectSubscriberGroupName)
.SendAsync(Constants.ClientProjectNotificationMethodName, new
{
CreatedProjectDto = createdProjectDto,
});
}
catch (Exception ex)
{
Console.WriteLine($"Encountered exception while attempting to publish project creation to subscribers. Message: {ex.Message}.");
Console.WriteLine(ex.StackTrace);
}
return(Ok(createdProjectDto));
}
public async Task <ProjectDto> CreateAsync(CreateProjectDto dto, int userId, CancellationToken cancellationToken)
{
var entity = fMapper.Map <CreateProjectDto, ProjectEntity>(dto);
await InTrasactionAsync(async() =>
{
DbSet.Add(entity);
await fContext.SaveChangesAsync(cancellationToken);
entity.Permissions.Add
(
new ProjectPermissionEntity
{
UserId = userId,
ProjectId = entity.Id,
Type = PermissionType.Own
}
);
await fContext.SaveChangesAsync(cancellationToken);
}, cancellationToken);
// TODO: Think this over so it could be used with mapper
return(new ProjectDto
{
Id = entity.Id,
Name = entity.Name,
Description = entity.Description,
CurrencyType = entity.CurrencyType,
UserPermission = PermissionType.Own
});
}
public async Task <IActionResult> Post([FromBody] CreateProjectDto project)
{
var p = project.ToProject();
await _dbService.AddAsync(p);
return(CreatedAtAction("GetOne", new { p.Id }));
}
/// <summary>
/// Creates a new project
/// </summary>
/// <param name="name">Name of the project</param>
/// <param name="visibility">Visibility of the project</param>
/// <returns>Response wrapped in JSON object</returns>
public async Task <JObject> Create(string name, string visibility)
{
string response;
var dto = new CreateProjectDto
{
Name = name,
Description = "Generated project by DevOpsApiClient",
Visibility = visibility,
Capabilities = new Capabilities
{
VersionControl = new VersionControl
{
SourceControlType = "Git"
},
ProcessTemplate = new ProcessTemplate
{
TemplateTypeId = "adcc42ab-9882-485e-a3ed-7678f01f66bc"
}
},
};
using (var client = new AzureHttpClient(Credentials.AccessToken))
{
using (var responseMessage =
await client.PostAsync(GenerateUrl("/projects", false), HttpConvert.ToRequestBody(dto)))
{
response = await responseMessage.Content.ReadAsStringAsync();
}
}
return(JObject.Parse(response));
}
public ActionResult <ProjectDto> CreateProject(Guid personId, [FromBody] CreateProjectDto dto)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!_db.Person.BelongsToUser(personId, HttpContext))
{
return(Forbid());
}
var projectWithThisName = _db.Project.FindByCondition(x => x.Name == dto.Name).SingleOrDefault();
if (projectWithThisName != null)
{
return(BadRequest(nameof(ProjectNameUniqueException)));
}
var project = _mapper.Map <Project>(dto);
_db.Project.Create(project);
var role = new Role
{
ProjectId = project.Id,
Name = "Administrator",
CalendarRead = true,
CalendarWrite = true,
KnowledgeBaseRead = true,
KnowledgeBaseWrite = true,
ParticipantsRead = true,
ParticipantsWrite = true,
RolesRead = true,
RolesWrite = true,
SettingsRead = true,
SettingsWrite = true,
Editable = false,
};
_db.Role.Create(role);
var participation = new Participation
{
ProjectId = project.Id,
PersonId = personId,
RoleId = role.Id,
Status = nameof(ParticipationStatus.Active),
};
_db.Participation.Create(participation);
_db.Save();
return(Ok(_mapper.Map <ProjectDto>(project)));
}
catch (Exception e)
{
_logger.LogError($"ERROR in CreateProject: {e.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> CreateProject([FromBody] CreateProjectDto dto)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
var project = await _projectsAppService.CreateProjectAsync(user, dto.Name);
return(CreatedAtAction(nameof(GetProjectById), new { Id = project.Id }, project));
}
public async Task <IActionResult> CreateProject([FromBody] CreateProjectDto project)
{
await userService.CreateProjectAsync(project.Title, project.Title, project.Due,
Int32.Parse(httpContextAccessor.HttpContext.User
.FindFirst("Id").Value));
return(Ok());
}
public IActionResult New(CreateProjectDto dto)
{
return(withUser(Request, user =>
{
var result = _projectService.CreateProject(user.Id, dto);
return new JsonResult(result);
}));
}
public async Task Create(CreateProjectDto projectDto)
{
await _context.Projects.AddAsync(new Projects
{
Name = projectDto.Name,
Description = projectDto.Description,
OrganisationId = projectDto.OrganisationId
});
}
public ActionResult Create(CreateProjectDto task)
{
var id = _projectAppService.CreateProject(task);
var input = new ProjectSearchInputDto();
var output = _projectAppService.SearchProjects(input);
return(PartialView("_ListProjects", output.Projects));
}
public async void testUpdateProject()
{//TODO add all types of projects
var client = _factory.CreateClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _projectsEnv._stringDict.GetValueOrDefault("token"));
var folder = new CreateFolderDto
{
description = "test",
name = "test1",
icon = "test3"
};
var actualResponseFolder = await client.testSuccessPostAsync <GetFolderDto, CreateFolderDto>("/api/folders", folder);
var responseTimersGet = await client.testSuccessGetAsync <List <GetTimerDto> >("/api/timers");
var newTimerId = responseTimersGet.data.FirstOrDefault(x => x.id != _projectsEnv._stringDict.GetValueOrDefault("timerId")).id;
var project = new CreateProjectDto
{
projectType = PROJECT_TYPE.ENERGY,
name = "test10",
stats = new STATS[] { STATS.EMOTIONS },
dominantStat = STATS.EMOTIONS,
folderId = actualResponseFolder.data.id,
defaultTimerId = newTimerId
};
var expectedProject = new GetProjectDto
{
name = project.name,
stats = project.stats,
dominantStat = project.dominantStat,
projectType = project.projectType,
folderId = project.folderId,
defaultTimerId = project.defaultTimerId
};
// Act
var actualResponseProject = await client
.testSuccessPutAsync <GetProjectDto, CreateProjectDto>($"/api/projects/{_projectsEnv._stringDict.GetValueOrDefault("projectId")}", project);
// Assert
expectedProject.WithDeepEqual(actualResponseProject.data)
.SkipDefault <DateTime>()
.IgnoreSourceProperty(x => x.id)
.IgnoreDestinationProperty(x => x.dateCreated)
.Assert();
// Act
var actualResponseProjectGet = await client.testSuccessGetAsync <GetProjectDto>("/api/projects/" + actualResponseProject.data.id);
expectedProject.id = actualResponseProject.data.id;
// Assert
expectedProject.WithDeepEqual(actualResponseProjectGet.data)
.SkipDefault <DateTime>()
.IgnoreDestinationProperty(x => x.dateCreated)
.Assert();
}
public async Task Create(CreateProjectDto input)
{
if (input.ShouldCreateAsanaTask)
{
await CreateTasksForAsana(input);
}
else
{
//await SaveTaskForDevOps(input);
}
}
public void CreateProject(CreateProjectDto newProject)
{
var project = new Project
{
Customer = (int)newProject.Customer,
Name = newProject.Name
};
_context.Project.Add(project);
_context.SaveChanges();
}
public async Task Create(ProjectViewModel projectViewModel)
{
var project = new CreateProjectDto
{
Name = projectViewModel.Name,
Code = projectViewModel.Code,
Budget = projectViewModel.Budget,
VinculationTypeId = projectViewModel.VinculationId
};
await _projectService.Create(project);
}
public IActionResult InsertProject(CreateProjectDto projectDto)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid data."));
}
else
{
projectRepository.InsertProject(projectDto);
}
return(Ok());
}
public async Task <Project> InsertProject(String partitionKey, CreateProjectDto body)
{
var entity = new Project();
entity.PartitionKey = partitionKey;
entity.RowKey = body.Name;
entity.Color = body.Color;
var operation = TableOperation.InsertOrReplace(entity);
await _projectTable.ExecuteAsync(operation);
return(entity);
}
public IActionResult InsertProject(CreateProjectDto projectDto)
{
var userID = User.FindFirst(ClaimTypes.NameIdentifier).Value;
projectDto.ProjectManagerID = userID;
if (ModelState.IsValid)
{
projectRepository.InsertProject(projectDto);
return(RedirectToAction("ShowProjectManagerProjects"));
}
else
{
return(RedirectToAction("Create"));
}
}
public async Task <int> Post([FromBody] CreateProjectDto projectDto)
{
var project = mapper.Map <Project>(projectDto);
project.ProjectUsers = userService.GetAll()
.Where(x => projectDto.UserNames.Contains(x.UserName))
.Select(user => new ProjectUser {
UserId = user.Id, Project = project
})
.ToList();
await projectService.Create(project);
return(project.Id);
}
public CreateProjectResultDto CreateProject(int userId, CreateProjectDto dto)
{
var record = _projectRepository.Save(new ProjectRecord {
UserId = userId,
Title = dto.Title,
Colour = dto.Colour
});
_projectMembershipRepository.Save(new ProjectMembershipRecord {
UserId = userId, ProjectId = record.Id
});
return(new CreateProjectResultDto {
Id = record.Id
});
}
public void UpdateProject(CreateProjectDto request)
{
var existingProject = _context.Project
.Where(x => x.Id == request.Id)
.FirstOrDefault();
if (request.Customer != null)
{
existingProject.Customer = (int)request.Customer;
}
if (request.Name != null)
{
existingProject.Name = request.Name;
}
_context.SaveChanges();
}
public async Task <ProjectDto> CreateProject(CreateProjectDto request, CancellationToken cancellationToken)
{
Project createdProject = Project.CreateProject(request.OwnerId, request.Name, request.Description, request.State);
await _projectRepository.Add(createdProject, cancellationToken);
ProjectUser projectUserLink = ProjectUser.CreateProjectUser(createdProject.Id, request.OwnerId, createdProject);
await _projectRepository.AddProjectUser(projectUserLink, cancellationToken);
foreach (string technologyName in request.Technologies)
{
Technology technology = await _projectRepository.GetTechnologyByName(technologyName);
await _projectRepository.AddProjectTechnology(createdProject, technology, cancellationToken);
}
return(_mapper.Map <ProjectDto>(createdProject));
}
