public CreateClassResponse CreateClass(CreateClassRequest request)
{
tryInitDB();
var data = request.data;
data.id = Guid.NewGuid().ToString();
using (var connection = new SqliteConnection("Data Source=conn.db")) {
connection.Open();
using (var trans = connection.BeginTransaction())
{
{
var command = connection.CreateCommand();
command.CommandText =
@"
INSERT INTO class (id,name)
VALUES ($id,$name)
";
command.Parameters.AddWithValue("$id", data.id);
command.Parameters.AddWithValue("$name", data.name);
command.ExecuteNonQuery();
}
{
foreach (var student in data.students)
{
student.id = Guid.NewGuid().ToString();
student.class_id = data.id;
var command = connection.CreateCommand();
command.CommandText =
@"
INSERT INTO student (id,class_id,name,no,gender)
VALUES ($id,$class_id,$name,$no,$gender)
";
command.Parameters.AddWithValue("$id", student.id);
command.Parameters.AddWithValue("$class_id", student.class_id);
command.Parameters.AddWithValue("$name", student.name);
command.Parameters.AddWithValue("$no", student.no);
command.Parameters.AddWithValue("$gender", student.gender);
command.ExecuteNonQuery();
}
}
trans.Commit();
}
}
return(new CreateClassResponse()
{
status = ResponseStatus.sussess,
data = data
});
}
public void Validate_ModelNull_ThrowsException()
{
CreateClassRequest input = null;
Action action = () => _sut.Validate(input);
action.Should().Throw <ArgumentNullException>();
}
public void Validate_ValidName_ReturnsNull()
{
CreateClassRequest input = _fixture.Build <CreateClassRequest>()
.With(x => x.Name, _fixture.Create <string>())
.Create();
Application.Validation.ValidationMessage result = _sut.Validate(input);
result.Should().BeNull();
}
public async Task <BaseResponseDto <ClassDto> > Handle(CreateClassRequest request, CancellationToken cancellationToken)
{
BaseResponseDto <ClassDto> response = new BaseResponseDto <ClassDto>();
try
{
System.Security.Claims.ClaimsPrincipal claims = new System.Security.Claims.ClaimsPrincipal();
var identifier = claims.Claims.FirstOrDefault(predicate => predicate.Type == "id");
if (identifier == null)
{
response.Errors.Add("Yetkilendirme hatası");
response.Data = null;
}
else
{
var user = await _repositoryWrapper.User.Find(int.Parse(identifier.ToString()));
if (user.UserRole != "Admin")
{
response.Errors.Add("Sınıf oluşturmak için yetkiniz bulunmamaktadır.");
response.Data = null;
}
else
{
var newClass = new Class
{
CreatedAt = DateTime.Now,
EducationYear = request.EducationYear,
ModifiedAt = DateTime.Now,
Name = request.Name,
AlphaNumericCode = AlphanumericCodeGenerator(8)
};
await _repositoryWrapper.Class.Create(newClass);
if (await _repositoryWrapper.SaveChangesAsync())
{
response.Data = newClass.Adapt <ClassDto>();
}
else
{
response.Errors.Add("Veri tabanı kayıt esnasında bir sorun oluştu.");
}
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.InnerException.Message);
response.Errors.Add(ex.InnerException.Message);
response.Errors.Add("Class oluşturulurken bir hata oluştu.");
}
return(response);
}
public void Validate_InvalidName_ReturnsValidationMessage()
{
CreateClassRequest input = _fixture.Build <CreateClassRequest>()
.With(x => x.Name, string.Empty)
.Create();
Application.Validation.ValidationMessage result = _sut.Validate(input);
result.Should().NotBeNull();
result.Field.Should().Be("Name");
result.Message.Should().Be("Name is required");
}
public async Task<IActionResult> Create(CreateClassRequest request)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var result = await _classService.CreateClass(request);
if (result.IsSuccessed == false)
{
return BadRequest(result);
}
return Ok(result);
}
/// <summary>
/// Creates a class
/// </summary>
public async Task <CreateClassResult> CreateClassAsync(CreateClassRequest model)
{
IEnumerable <ValidationMessage> validationMessages = _classValidator.ValidateRules(model);
if (validationMessages.Any())
{
return(new CreateClassResult(validationMessages));
}
var @class = new Class(Name.CreateFromString(model.Name));
await _classRepository.CreateAsync(@class);
return(new CreateClassResult(@class.Id));
}
public async Task <ApiResult <bool> > CreateClass(CreateClassRequest request)
{
var classes = new Class()
{
Name = request.Name,
Description = request.Description,
DateCreate = DateTime.UtcNow.AddHours(7),
DateUpdate = DateTime.UtcNow.AddHours(7),
};
_context.Classes.Add(classes);
await _context.SaveChangesAsync();
return(new ApiSuccessResult <bool>("Tạo thành Lớp học thành công"));
}
/// <summary>
/// * 用于对媒体进行分类管理；
/// * 该接口不影响既有媒体的分类，如需修改媒体分类，请调用[修改媒体文件属性](/document/product/266/31762)接口。
/// * 分类层次不可超过 4 层。
/// * 每个分类的子类数量不可超过 500 个。
/// </summary>
/// <param name="req">参考<see cref="CreateClassRequest"/></param>
/// <returns>参考<see cref="CreateClassResponse"/>实例</returns>
public async Task <CreateClassResponse> CreateClass(CreateClassRequest req)
{
JsonResponseModel <CreateClassResponse> rsp = null;
try
{
var strResp = await this.InternalRequest(req, "CreateClass");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateClassResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
private async Task <Guid> CreateClassFlowAsync()
{
Console.WriteLine("What is the name of the class?");
string className = Console.ReadLine();
var createClassRequest = new CreateClassRequest()
{
Name = className
};
CreateClassResult createClassResponse = await _classController.CreateClassAsync(createClassRequest);
Guid classId = createClassResponse.ClassId;
if (createClassResponse.ValidationMessages.Any())
{
SharedConsoleFlows.PrintValidationMessages(createClassResponse.ValidationMessages);
classId = await CreateClassFlowAsync();
}
return(classId);
}
public async Task <IActionResult> Create([FromBody] CreateClassRequest request)
{
var claims = _jwtService.GetTokenClaims(Request.Headers["JWToken"]);
var email = claims.First().Value;
var user = await _userService.GetByEmail(email);
if (user == null)
{
return(Response(code: 404));
}
var createdClass = await _classService.Register(request, user);
if (createdClass != null)
{
return(Response(createdClass, 201));
}
else
{
return(Response(code: 400));
}
}
public async Task <ClassResponse> Register(CreateClassRequest request, User user)
{
if (user == null)
{
Notify("User not found");
}
if (!HasNotification())
{
var newClass = new Class(request.Name, user);
var createdClass = await _classRepository.Add(newClass);
return(new ClassResponse()
{
Id = createdClass.Id,
Name = createdClass.Name
});
}
else
{
return(null);
}
}
public Task <ClassResponse> Update(CreateClassRequest request, User user)
{
throw new System.NotImplementedException();
}
public async Task <BaseResponseDto <ClassDto> > CreateClassAsync(CreateClassRequest createClassRequest)
{
BaseResponseDto <ClassDto> response = await _mediator.Send(createClassRequest);
return(response);
}
