public async Task CreateDeveloper(CreateDto createDeveloperDto)
{
var Dev = new Developer()
{
FirstName = createDeveloperDto.FirstName,
LastName = createDeveloperDto.LastName,
UserName = createDeveloperDto.UserName,
Email = createDeveloperDto.UserName,
PhoneNumber = createDeveloperDto.PhoneNumber,
EmailConfirmed = true
};
var result = await userManager.CreateAsync(Dev, createDeveloperDto.Password);
if (result.Succeeded)
{
db.UserRoles.Add(new IdentityUserRole <string>()
{
UserId = Dev.Id,
RoleId = "3"
});
db.SaveChanges();
}
else
{
throw new Exception();
}
}
public IActionResult Create([FromBody] CreateDto createDto)
{
var user = _context.Users.FirstOrDefault(u => u.Username == createDto.Username && u.Password == createDto.Password);
if (user != null)
{
return(BadRequest());
}
var token = Guid.NewGuid();
user = new User
{
Id = Guid.NewGuid(),
DisplayName = createDto.DisplayName,
Username = createDto.Username,
Password = createDto.Password,
Token = token
};
Session.TokenDictionary.Add(token, user.Id);
_context.Users.Add(user);
_context.SaveChanges();
return(Ok(user));
}
public async Task <IActionResult> Create([FromBody] CreateDto creatModel)
{
if (ModelState.IsValid)
{
var user = new IdentityUser()
{
Email = creatModel.Email,
UserName = creatModel.UserName
};
var result = await _userManager.CreateAsync(user, creatModel.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Users"));
}
else
{
foreach (var i in result.Errors)
{
ModelState.AddModelError("", i.Description);
}
}
}
return(Ok(creatModel));
}
public Task CreateAsync([FromBody] CreateDto createDto)
{
var creds = Convert(createDto.Creds);
var roles = createDto.Roles.Select(Convert).ToArray();
return(_identity.CreateAsync(creds, roles));
}
public async Task CreateTeamLeader(CreateDto createTeamLeaderDto)
{
var teamLeader = new TeamLeader()
{
FirstName = createTeamLeaderDto.FirstName,
LastName = createTeamLeaderDto.LastName,
UserName = createTeamLeaderDto.UserName,
Email = createTeamLeaderDto.UserName,
PhoneNumber = createTeamLeaderDto.PhoneNumber,
EmailConfirmed = true
};
var result = await userManager.CreateAsync(teamLeader, createTeamLeaderDto.Password);
if (result.Succeeded)
{
db.UserRoles.Add(new IdentityUserRole <string>()
{
UserId = teamLeader.Id,
RoleId = "2"
});
db.SaveChanges();
}
else
{
}
}
public IHttpActionResult Create(CreateDto newAttendee)
{
if (newAttendee.IsNotValid)
{
return(new ErrorResponse(
code: HttpStatusCode.BadRequest,
message: "Required field(s) are missing"
).SetErrorResponseIn(this));
}
var createCommand = new AttendeeCommand.Create(
firstName: newAttendee.FirstName,
lastName: newAttendee.LastName,
email: newAttendee.Email,
birthdate: DateTime.ParseExact(newAttendee.Birthdate, new [] {
"d.M.yyyy.",
"d.M.yyyy",
"d/M/yyyy",
"d-M-yyyy"
}, CultureInfo.InvariantCulture, DateTimeStyles.None),
workStatus: (WorkStatuses)newAttendee.WorkStatus,
createdOn: DateTime.Now
);
return(Ok(_attendeeCommand.Execute(createCommand)));
}
public ActionResult <ReadDto> CreateCommand(CreateDto com)
{
var commands = _Mappper.Map <Project>(com);
_repository.CreateCommand(commands);
_repository.SaveChanges();
var createdto = _Mappper.Map <ReadDto>(commands);
return(Ok(createdto));
}
public async Task <IActionResult> Add([FromBody] CreateDto dto)
{
if (_service.IsExist(dto.Code))
{
return(new ConflictObjectResult("code is exists"));
}
_service.Add(dto.Code, dto.Name);
return(Ok());
}
public ActionResult <ReadDto> CreateTransaction(CreateDto transactionCreateDto)
{
var transactionModel = _mapper.Map <Transaction>(transactionCreateDto);
_repository.CreateTransaction(transactionModel);
_repository.SaveChanges();
var transactionReadDto = _mapper.Map <ReadDto>(transactionModel);
return(CreatedAtRoute(nameof(GetTransactionById), new { Id = transactionReadDto.Id }, transactionReadDto));
}
public async Task <CreateDto> CheckStudent(CreateDto guidStudent)
{
var Name = await _context.Students.Where(s => s.GuId == Common.Common.MD5(guidStudent.Name)).Select(s => s.Name).FirstOrDefaultAsync();
var Result = new CreateDto
{
Name = Name
};
return(Result);
}
public async Task <IActionResult> Lectures(CreateDto Input)
{
var x = await _context.Lectures.AddAsync(new Lecture { Name = Input.Name });
await _context.SaveChangesAsync();
var l = new LectureDto {
Id = x.Entity.Id, Name = x.Entity.Name
};
return(Ok(l));
}
public async Task <IActionResult> CreateManager(CreateDto createManagerDto)
{
if (ModelState.IsValid)
{
await userManagerRepository.CreateManager(createManagerDto);
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
public ActionResult Create(CreateDto model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
_repo.Create(new TestEntity
{
Name = model.Name
});
return(RedirectToAction("Index"));
}
public async Task <IActionResult> CreateTeamLeader(CreateDto createDto)
{
{
if (ModelState.IsValid)
{
await userTeamLeaderRepository.CreateTeamLeader(createDto);
return(Redirect("Index"));
}
else
{
return(View());
}
}
}
public async Task <IActionResult> AddUser([FromForm] CreateDto create)
{
var newUser = new ApplicationUser {
UserName = create.UserName, Id = _generator.NextId()
};
var result = await _userManager.CreateAsync(newUser, create.Password);
var result2 = await _userManager.AddToRoleAsync(newUser, create.Role);
if (result.Succeeded && result2.Succeeded)
{
return(Created(HttpContext.Request.GetDisplayUrl(), new { Success = true }));
}
return(BadRequest(result.Errors));
}
public async Task <IActionResult> Students(CreateDto Input)
{
var guid = Guid.NewGuid();
var x = await _context.Students.AddAsync(new Student
{
GuId = Common.Common.MD5(guid.ToString()),
Name = Input.Name
});
await _context.SaveChangesAsync();
var t = new StudentGradesLectures
{
Guid = guid.ToString(),
Id = x.Entity.Id,
Name = x.Entity.Name
};
return(Ok(t));
}
public IHttpActionResult Create(CreateDto newUser)
{
if (newUser.IsNotValid)
{
return(new ErrorResponse(
code: HttpStatusCode.BadRequest,
message: "Required field(s) are missing"
).SetErrorResponseIn(this));
}
var createCommand = new UserCommand.Create(
username: newUser.Username,
role: (Roles)newUser.Role
);
return(_userCommand.Execute(createCommand) == ActionResult.Success
? Ok()
: new ErrorResponse(
code: HttpStatusCode.BadRequest,
message: "Username is already taken"
).SetErrorResponseIn(this));
}
