public ActionResult Insert()
{
var model = new DefinitionViewModel();
model.Operation = "I";
return(View("InsertEdit", model));
}
public async Task <IActionResult> Create(DefinitionViewModel model)
{
User user = await _userManager.FindByNameAsync(User.Identity.Name);
if (ModelState.IsValid && user != null)
{
Definition definition = new Definition()
{
Name = model.Name,
Description = model.Description,
Example = model.Example,
UserId = user.Id,
CreationDate = DateTime.Now,
AuthorUsername = user.UserName,
Hashtags = _hashtagParser.Parse(model.Hashtags)
};
await _context.Definitions.AddAsync(definition);
user.Definitions.Add(definition);
_context.SaveChanges();
}
else
{
return(RedirectToAction("Index", "Feed"));
}
return(RedirectToAction("Index", "Feed"));
}
public async Task <ProfessionalExperienceDefinition> Create(DefinitionViewModel input)
{
ProfessionalExperienceDefinition newProfessionalExperienceDefinition = new ProfessionalExperienceDefinition
{
Name = input.Name,
Start = input.Start,
End = input.End,
Year = input.Year,
NumberOfDays = input.NumberOfDays,
NumberOfHours = input.NumberOfHours,
Active = input.Active,
Longtime = input.Longtime,
DefinitionRepresentative = input.DefinitionRepresentative,
DefinitionRepresentativeEmail = input.DefinitionRepresentativeEmail,
DefinitionRepresentativeTelephoneNumber = input.DefinitionRepresentativeTelephoneNumber,
};
_context.ProfessionalExperienceDefinitions.Add(newProfessionalExperienceDefinition);
await _context.SaveChangesAsync();
foreach (var i in input.ClassroomIds)
{
var classroomDefinition = new ClassroomDefinition {
ClassroomId = i, DefinitionId = newProfessionalExperienceDefinition.Id
};
_context.ClassroomDefinitions.Add(classroomDefinition);
}
await _context.SaveChangesAsync();
return(newProfessionalExperienceDefinition);
}
private void InitDynamic()
{
DynamicVM = new DefinitionViewModel();
DynamicVM.DoubleClickCommand = new DelegateCommand(SearchFromSelection);
keyboardHook = new GlobalKeyboardHook();
clipboardManager = new ClipboardManager();
}
public ActionResult AddDefinitionForm(int id)
{
using (var db = new DBContext())
{
var term = db.Terms.Find(id);
var model = new DefinitionViewModel()
{
IdTerm = term.IdTerm, TermName = term.TermName
};
return(PartialView("AddDefinition", model));
}
}
public DefinitionPage(TrainingViewModel parent, CharDef[] list)
{
InitializeComponent();
Parent = parent;
DefinitionScrollList.ItemsSource = items;
foreach (CharDef cd in list)
{
items.Add(cd);
}
BindingContext = DefinitionViewModel = new DefinitionViewModel(parent);
}
private void InitLearner()
{
wordList = new List <string>();
historyWordlist = new List <string>();
LearnerVM = new DefinitionViewModel();
spawnTimer = new DispatcherTimer();
spawnTimer.Tick += OnSpawnTimerTick;
spawnTimer.Interval = new TimeSpan(hours: 0, minutes: 0, seconds: 1);
activeTimer = new DispatcherTimer();
activeTimer.Tick += OnActiveTimerTick;
activeTimer.Interval = new TimeSpan(hours: 0, minutes: 0, seconds: 1);
}
public async Task <ProfessionalExperienceDefinition> Update(int id, DefinitionViewModel input)
{
ProfessionalExperienceDefinition professionalExperienceDefinition = _context.ProfessionalExperienceDefinitions.Find(id);
if (professionalExperienceDefinition != null)
{
professionalExperienceDefinition.Name = input.Name;
professionalExperienceDefinition.Start = input.Start;
professionalExperienceDefinition.End = input.End;
professionalExperienceDefinition.Year = input.Year;
professionalExperienceDefinition.NumberOfDays = input.NumberOfDays;
professionalExperienceDefinition.NumberOfHours = input.NumberOfHours;
professionalExperienceDefinition.Active = input.Active;
professionalExperienceDefinition.Longtime = input.Longtime;
professionalExperienceDefinition.DefinitionRepresentative = input.DefinitionRepresentative;
professionalExperienceDefinition.DefinitionRepresentativeEmail = input.DefinitionRepresentativeEmail;
professionalExperienceDefinition.DefinitionRepresentativeTelephoneNumber = input.DefinitionRepresentativeTelephoneNumber;
await _context.SaveChangesAsync();
foreach (var i in _context.ClassroomDefinitions)
{
if (i.DefinitionId == id)
{
_context.ClassroomDefinitions.Remove(i);
}
}
await _context.SaveChangesAsync();
foreach (var i in input.ClassroomIds)
{
var classroomDefinition = new ClassroomDefinition {
ClassroomId = i, DefinitionId = id
};
_context.ClassroomDefinitions.Add(classroomDefinition);
}
await _context.SaveChangesAsync();
return(professionalExperienceDefinition);
}
else
{
return(null);
}
}
public ActionResult AddDefinition(DefinitionViewModel model)
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <Definition, DefinitionViewModel>()
.ForMember("TermName", opt => opt.MapFrom(c => c.Term.TermName))
.ForMember("Freq", opt => opt.MapFrom(c => c.Projects.Count));
cfg.CreateMap <DefinitionViewModel, Definition>();
});
using (var db = new DBContext())
{
var data = Mapper.Map <DefinitionViewModel, Definition>(model);
db.Definitions.Add(data);
db.SaveChanges();
var term = db.Terms.Find(data.IdTerm);
var definitions = Mapper.Map <IEnumerable <Definition>, IEnumerable <DefinitionViewModel> >(term.Definitions).OrderByDescending(x => x.Freq).Skip(1);
return(PartialView("OtherDefinitionsPartical", definitions));
}
}
public ActionResult InsertEdit(DefinitionViewModel model)
{
if (!ModelState.IsValid)
{
TempData["Error"] = "Transaction error";
return(RedirectToAction("Index", "Sectors"));
}
var entity = _mapper.Map <DefinitionViewModel, DefinitionEntity>(model);
var result = model.Operation == "E" ? _definitionsManager.Update(entity) : _definitionsManager.Insert(entity);
TempData["Result"] = result;
if (!result.Success)
{
return(RedirectToAction("Index"));
}
var operation = model.Operation == "E" ? "Edit Defitinion" : "Insert Defitinion";
StoreLog("Definition", operation, (int)result.Entity);
return(RedirectToAction("Edit", new { id = (int)result.Entity }));
}
public ActionResult UpdateDefinition(DefinitionViewModel model)
{
if (model != null)
{
using (var db = new DBContext())
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <DefinitionViewModel, Definition>();
});
var data = Mapper.Map <DefinitionViewModel, Definition>(model);
if (data.IdDefinition > 0)
{
db.Entry(data).State = EntityState.Modified;
}
db.SaveChanges();
return(PartialView("DefinitionPartical", model));
}
}
return(null);
}
