public object insert([FromBody] JsonElement json)
{
var model = JsonConvert.DeserializeObject <SubjectGroup>(json.GetRawText());
if (model == null)
{
return(CreatedAtAction(nameof(insert), new { result = ResultCode.InputHasNotFound, message = ResultMessage.InputHasNotFound }));
}
var group = _context.SubjectGroups.Where(w => w.Name == model.Name).FirstOrDefault();
if (group != null)
{
return(CreatedAtAction(nameof(insert), new { result = ResultCode.DuplicateData, message = ResultMessage.DuplicateData }));
}
group = new SubjectGroup();
group.Color1 = model.Color1;
group.Color2 = model.Color2;
group.Color3 = model.Color3;
group.Create_On = DateUtil.Now();
group.Update_On = DateUtil.Now();
group.Create_By = model.Update_By;
group.Update_By = model.Update_By;
group.Status = model.Status;
group.Name = model.Name;
group.DoExamOrder = model.DoExamOrder;
_context.SubjectGroups.Add(group);
_context.SaveChanges();
return(CreatedAtAction(nameof(insert), new { result = ResultCode.Success, message = ResultMessage.Success }));
}
public async Task <SubjectGroup> Create(SubjectGroup subjectGroup)
{
subjectGroup.Id = Guid.NewGuid();
if (!await SubjectGroupValidator.Create(subjectGroup))
{
return(subjectGroup);
}
try
{
await UOW.Begin();
await UOW.SubjectGroupRepository.Create(subjectGroup);
await UOW.Commit();
return(await Get(subjectGroup.Id));
}
catch (Exception ex)
{
await UOW.Rollback();
throw new MessageException(ex);
}
}
private void UpdateSubjectGroupMemberships(Subject subject)
{
SubjectGroup oldSubjectGroup = subject.SubjectGroup;
SubjectGroup newSubjectGroup = (SubjectGroup)cbSubjectGroup.SelectedItem;
if (newSubjectGroup.Id == -1)
{
newSubjectGroup = null;
}
if (subject.SubjectGroup == null)
{
if (newSubjectGroup != null)
{
newSubjectGroup.AddSubject(subject);
newSubjectGroup.Save();
}
}
else if (newSubjectGroup == null)
{
subject.SubjectGroup = null;
oldSubjectGroup.Subjects.Remove(subject);
oldSubjectGroup.Save();
}
else if (subject.SubjectGroup.Id != newSubjectGroup.Id)
{
oldSubjectGroup.Subjects.Remove(subject);
newSubjectGroup.AddSubject(subject);
oldSubjectGroup.Save();
newSubjectGroup.Save();
}
}
private void LoadDisciplines(long SemesterID)
{
teacherIndex = App.API.TeacherGetIndex(SemesterID);
CurrentSemID = SemesterID;
Title = $"БРС - {SemesterList.Find(s=> s.Id == CurrentSemID)}";
GroupedDisciplineItems1.Clear();
if (teacherIndex.Subjects != null)
{
EmptyListText.IsVisible = false;
foreach (var s in teacherIndex.Subjects)
{
var group = new SubjectGroup($"{s.Value.SubjectName} \n{s.Value.Degree}, {s.Value.GradeNum} курс");
foreach (var d in s.Value.Disciplines)
{
group.Add(new DisciplineItem(
$"{s.Value.SubjectName} \n{s.Value.Degree}, {s.Value.GradeNum} курс",
d.Id,
string.Join('\n', teacherIndex.Groups[d.Id.ToString()]),
d.TypeToString(),
string.Join('\n', teacherIndex.Teachers[d.Id.ToString()].Values.Select(t => t.ShortName()).Take(4))
));
}
GroupedDisciplineItems1.Add(group);
}
}
else
{
EmptyListText.IsVisible = true;
}
}
private Subject(string name, string shortName, SubjectGroup group, bool isOptional = false)
{
this.name = name;
this.shortName = shortName;
this.group = group;
this.isOptional = isOptional;
}
public SubjectGroupModel CreateOrUpdate(SubjectGroupModel model)
{
Logger.Debug($"{model}");
if (model == null)
{
throw new System.ArgumentNullException("model");
}
SubjectGroup subjectGroup = null;
if (model.Id == null || model.Id == System.Guid.Empty)
{
subjectGroup = this.UnitOfWork.SubjectGroupRepository.CreateSubjectGroup(model.SemesterId, model.Name, model.Code, model.HighlightColor, model.IsActive);
}
else
{
subjectGroup = this.UnitOfWork.SubjectGroupRepository.UpdateSubjectGroup(model.Id, model.Name, model.Code, model.HighlightColor, model.IsActive);
}
this.UnitOfWork.SaveChanges();
SubjectGroupModel subjectGroupModel = Mapper.Map <Models.SubjectGroup, Models.SubjectGroupModel>(subjectGroup);
return(subjectGroupModel);
}
private void bSave_Click(object sender, EventArgs e)
{
try
{
if (!ValidateChildren())
{
ShowInputError();
return;
}
SubjectGroup subjectGroup = _subjectGroup ?? new SubjectGroup();
subjectGroup.Name = txtName.Text;
if (_subjectGroup == null)
{
Researcher.Current.ActiveProject.AddSubjectGroup(subjectGroup);
Researcher.Current.ActiveProject.Save();
if (CallerForm is ListForm <SubjectGroup> )
{
(CallerForm as ListForm <SubjectGroup>).OrderRefresh(subjectGroup);
}
}
else
{
_subjectGroup.Save();
}
this.Close();
}
catch (Exception ex)
{
FailWithError(ex);
}
}
public GroupVm AttachSubjectToGroup(AttachDetachSubjectGroupDto attachSubjectGroup)
{
if (attachSubjectGroup == null)
{
throw new ArgumentNullException($"Dto of type is null");
}
var subjectGroup = _dbContext.SubjectGroup.FirstOrDefault(sg => sg.GroupId == attachSubjectGroup.GroupId && sg.SubjectId == attachSubjectGroup.SubjectId);
if (subjectGroup != null)
{
throw new ArgumentNullException($"There is such attachment already defined.");
}
subjectGroup = new SubjectGroup
{
GroupId = attachSubjectGroup.GroupId,
SubjectId = attachSubjectGroup.SubjectId
};
_dbContext.SubjectGroup.Add(subjectGroup);
_dbContext.SaveChanges();
var group = _dbContext.Groups.FirstOrDefault(x => x.Id == attachSubjectGroup.GroupId);
var groupVm = Mapper.Map <GroupVm>(group);
return(groupVm);
}
public async Task <ActionResult <SubjectGroupDTO> > Create([FromBody] SubjectGroupDTO subjectGroupDTO)
{
if (subjectGroupDTO == null)
{
subjectGroupDTO = new SubjectGroupDTO();
}
SubjectGroup subjectGroup = ConvertDTOtoBO(subjectGroupDTO);
subjectGroup = await SubjectGrupService.Create(subjectGroup);
subjectGroupDTO = new SubjectGroupDTO
{
Id = subjectGroup.Id,
Code = subjectGroup.Code,
Name = subjectGroup.Name,
Errors = subjectGroup.Errors
};
if (subjectGroup.HasError)
{
return(BadRequest(subjectGroupDTO));
}
return(Ok(subjectGroupDTO));
}
public async Task <bool> Create(SubjectGroup subjectGroup)
{
bool IsValid = true;
IsValid &= await CodeValidate(subjectGroup);
return(IsValid);
}
public override IEnumerable <StringField> GetField(SubjectGroup tripleGroup)
{
var any = tripleGroup.Any(FilterValidTriples);
return(any
? new[] { new StringField(FieldName, true.ToString(), Field.Store.YES) }
: new StringField[] { });
}
public override IEnumerable <StringField> GetField(SubjectGroup tripleGroup)
{
var values = TriplesToValue(tripleGroup);
return(values.Any()
? values.Select(x => new StringField(FieldName, x, Field.Store.YES))
: new List <StringField>());
}
public async Task <bool> Delete(SubjectGroup subjectGroup)
{
bool IsValid = true;
IsValid &= await IsExisted(subjectGroup);
return(IsValid);
}
public IEnumerable <StringField> GetField(SubjectGroup subjectGroup)
{
return(RelationIndex.Contains(subjectGroup.Id.ToInt())
? new List <StringField> {
new StringField(FieldName, true.ToString(), Field.Store.YES)
}
: new List <StringField>());
}
public override IEnumerable <TextField> GetField(SubjectGroup tripleGroup)
{
var values = SelectTripleValue(tripleGroup.FirstOrDefault(FilterValidTriples));
return(!string.IsNullOrWhiteSpace(values)
? new[] { new TextField(FieldName, values, Field.Store.YES) }
: new TextField[] { });
}
public SubjectGroupForm(SubjectGroup subjectGroup)
: this()
{
if (subjectGroup != null)
{
_subjectGroup = subjectGroup;
txtName.Text = subjectGroup.Name;
}
}
private async Task <bool> IsExisted(SubjectGroup subjectGroup)
{
//Kiểm tra Khối xét tuyển đã tồn tại chưa?
if (await UOW.SubjectGroupRepository.Get(subjectGroup.Id) == null)
{
subjectGroup.AddError(nameof(SubjectGroupValidator), nameof(subjectGroup.Name), ErrorCode.NotExisted);
}
return(subjectGroup.IsValidated);
}
public SubjectGroupForm(SubjectGroup subjectGroup)
: this()
{
if (subjectGroup != null)
{
_subjectGroup = subjectGroup;
txtName.Text = subjectGroup.Name;
}
}
public IEnumerable <string> TriplesToValue(SubjectGroup triples)
{
var values = triples.Where(FilterValidTriples)
.Select(SelectTripleValue)
.Distinct()
.Where(x => !string.IsNullOrWhiteSpace(x));
return(values);
}
public IEnumerable <StringField> RangeGetField(SubjectGroup subjectGroup)
{
var subjectId = subjectGroup.Id.ToInt();
return(RangeDictionary.ContainsKey(subjectId)
? RangeDictionary[subjectId]
.Select(x => new StringField(Labels.Range.ToString(), x.ToString(), Field.Store.YES))
: new List <StringField>());
}
public async Task <bool> Update(SubjectGroup subjectGroup)
{
await tFContext.SubjectGroup.Where(t => t.Id.Equals(subjectGroup.Id)).UpdateFromQueryAsync(t => new SubjectGroupDAO
{
Code = subjectGroup.Code,
Name = subjectGroup.Name
});
return(true);
}
public IEnumerable <DoubleField> GetField(SubjectGroup subjectGroup)
{
var subjectId = subjectGroup.Id.ToInt();
return(RelationIndex.ContainsKey(subjectId)
? new List <DoubleField> {
new DoubleField(FieldName, RelationIndex[subjectId], Field.Store.YES)
}
: new List <DoubleField>());
}
public async Task <SubjectGroup> Get(Guid Id)
{
if (Id == Guid.Empty)
{
return(null);
}
SubjectGroup subjectGroup = await UOW.SubjectGroupRepository.Get(Id);
return(subjectGroup);
}
public IEnumerable <StringField> GetField(SubjectGroup tripleGroup)
{
var value = tripleGroup.Id;
return(!string.IsNullOrWhiteSpace(value)
? new List <StringField> {
new StringField(FieldName, value, Field.Store.YES)
}
: new List <StringField>());
}
private SubjectGroup ConvertDTOtoBO(SubjectGroupDTO subjectGroupDTO)
{
SubjectGroup subjectGroup = new SubjectGroup
{
Id = subjectGroupDTO.Id ?? Guid.Empty,
Code = subjectGroupDTO.Code,
Name = subjectGroupDTO.Name
};
return(subjectGroup);
}
internal override void ParseTripleGroup(HashSet <int> hashSet, SubjectGroup subjectGroup)
{
var entityTypes = subjectGroup
.Where(x => x.Predicate.IsInstanceOf())
.Select(x => x.Object.GetIntId()).ToArray();
foreach (var entityType in entityTypes)
{
hashSet.Add(entityType);
}
}
public IEnumerable <DoubleField> FrequencyGetField(SubjectGroup subjectGroup)
{
var subjectId = subjectGroup.Id.ToInt();
return(FrequencyHashTable.ContainsKey(subjectId)
? new List <DoubleField>
{
new DoubleField(Labels.Rank.ToString(), (int)FrequencyHashTable[subjectId], Field.Store.YES)
}
: new List <DoubleField>());
}
public async Task <SubjectGroup> Get(long Id)
{
SubjectGroup subjectGroup = await context.SubjectGroup.Where(d => d.Id == Id).Select(d => new SubjectGroup
{
Id = d.Id,
Code = d.Code,
Name = d.Name
}).FirstOrDefaultAsync();
return(subjectGroup);
}
public async Task <SubjectGroup> Get(Guid Id)
{
SubjectGroup subjectGroup = await tFContext.SubjectGroup.Where(d => d.Id.Equals(Id)).Select(d => new SubjectGroup
{
Id = d.Id,
Code = d.Code,
Name = d.Name
}).FirstOrDefaultAsync();
return(subjectGroup);
}
public override IEnumerable <TextField> GetField(SubjectGroup tripleGroup)
{
var values = TriplesToValue(tripleGroup);
return(values.Any()
? new List <TextField> {
new TextField(FieldName, string.Join(Constants.PropertyValueSeparator, values), Field.Store.YES)
{
Boost = (float)Boost
}
}
: new List <TextField>());
}
public override IEnumerable <TextField> GetField(SubjectGroup tripleGroup)
{
var values = SelectTripleValue(tripleGroup.FirstOrDefault(FilterValidTriples));
return(!string.IsNullOrWhiteSpace(values)
? new List <TextField> {
new TextField(FieldName, string.Join(Constants.PropertyValueSeparator, values), Field.Store.YES)
{
Boost = (float)Boost
}
}
: new List <TextField>());
}
public SubjectForm()
{
InitializeComponent();
List<SubjectGroup> comboBoxSubjectGroups = new List<SubjectGroup>();
SubjectGroup emptySubjectGroup = new SubjectGroup();
emptySubjectGroup.Id = -1;
emptySubjectGroup.Name = "<None>";
comboBoxSubjectGroups.Add(emptySubjectGroup);
comboBoxSubjectGroups.AddRange(Researcher.Current.ActiveProject.SubjectGroups);
cbSubjectGroup.DataSource = comboBoxSubjectGroups;
cbSex.SelectedIndex = 1;
}
