public JsonResult Delete(int id)
{
try
{
if (id == 0)
{
return(Json(new { responseCode = "-10" }));
}
LanguageLevel model = this._languageLevelBusiness.GetLanguageLevel(id);
model.Enable = false;
this._languageLevelBusiness.Save(model);
var responseObject = new
{
responseCode = 0
};
return(Json(responseObject));
}
catch (Exception)
{
return(Json(new { responseCode = "-10" }));
}
}
internal void AddLanguage(string LangName, string LangLevel)
{
AddNewButton.Click(); //Click on AddNew button
AddNewLanTextInput.SendKeys(LangName); //enter language name
LanguageLevel.SendKeys(LangLevel); //enter language level
AddButton.Click(); //click on Add button
}
public void ShouldAddLanguageSkills()
{
var httpResult = controller.Get(1);
var response = httpResult as JsonResult <CandidateDTO>;
var candidate = response.Content;
int languageId = context.Languages.First().Id;
LanguageLevel languageLevel = LanguageLevel.Advanced;
var newLanguageSkill = new LanguageSkillDTO
{
LanguageId = languageId,
LanguageLevel = languageLevel
};
var languageSkills = candidate.LanguageSkills.ToList();
languageSkills.Add(newLanguageSkill);
candidate.LanguageSkills = languageSkills;
var newHttpResult = controller.Put(candidate.Id, candidate);
var newResponse = newHttpResult as JsonResult <CandidateDTO>;
var newCandidate = newResponse.Content;
Assert.IsTrue(newCandidate.LanguageSkills.Any(x => x.LanguageId == languageId && x.LanguageLevel == languageLevel));
}
/// <summary>
/// Delete User Action Activity Log
/// </summary>
/// <param name=></param>
/// <returns>bool</returns>
public async Task <bool> DeleteLanguageLevel(int LanguageLevelId)
{
#region Declare a return type with initial value.
bool isLanguageLevelDeleted = default(bool);
#endregion
try
{
if (LanguageLevelId > default(int))
{
#region Vars
LanguageLevel LanguageLevel = null;
#endregion
#region Get LanguageLevel by id
LanguageLevel = await UnitOfWork.LanguageLevelRepository.GetById(LanguageLevelId);
#endregion
#region check if object is not null
if (LanguageLevel != null)
{
LanguageLevel.IsDeleted = (byte)DeleteStatusEnum.Deleted;
#region Apply the changes to the database
UnitOfWork.LanguageLevelRepository.Update(LanguageLevel);
isLanguageLevelDeleted = await UnitOfWork.Commit() > default(int);
#endregion
}
#endregion
}
}
catch (Exception exception)
{
}
return(isLanguageLevelDeleted);
}
public async Task <IActionResult> PutLanguageLevel(int id, LanguageLevel languageLevel)
{
if (id != languageLevel.Id)
{
return(BadRequest());
}
_context.Entry(languageLevel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LanguageLevelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//for testing
public Language(string name, LanguageLevel listen, LanguageLevel speaking, LanguageLevel writing)
{
Name = name;
LevelOfListening = listen;
LevelOfSpeaking = speaking;
LevelOfWriting = writing;
}
public bool UpdateLanguageLevelDetails(LanguageLevel details)
{
List <SqlParameter> sp = new List <SqlParameter>()
{
new SqlParameter()
{
ParameterName = "@name", Value = details.Name, SqlDbType = SqlDbType.NChar
},
new SqlParameter()
{
ParameterName = "@lagLevel_Id", Value = details.LagLevel_Id, SqlDbType = SqlDbType.BigInt
},
};
object[] parameters = sp.ToArray();
var users = _languageLevelRepository.ExecuteStoredProcedureList <AuthUser>(PROC_UPDATE_LANGUAGE_LEVEL_DETAILS, parameters);
if (users != null)
{
return(true);
}
else
{
return(false);
}
}
public async Task <ActionResult <LanguageLevel> > PostLanguageLevel(LanguageLevel languageLevel)
{
_context.LanguageLevel.Add(languageLevel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetLanguageLevel", new { id = languageLevel.Id }, languageLevel));
}
public CodeGenerator(LanguageLevel level)
{
Context = new Context( );
Module = new BitcodeModule(Context, "Kaleidoscope");
InstructionBuilder = new InstructionBuilder(Context);
NamedValues = new Dictionary <string, Value>( );
ParserStack = new ReplParserStack(level);
}
private void Update(LanguageLevel view)
{
LanguageLevel model = GetLanguageLevel(view.Id);
model.Name = view.Name;
this.repository.Update(view);
}
public ActionResult DeleteConfirmed(int id)
{
LanguageLevel languageLevel = db.LanguageLevels.Find(id);
db.LanguageLevels.Remove(languageLevel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public CodeGenerator(LanguageLevel level, TargetMachine machine)
{
Context = new Context( );
TargetMachine = machine;
InstructionBuilder = new InstructionBuilder(Context);
NamedValues = new Dictionary <string, Alloca>( );
FunctionPrototypes = new PrototypeCollection( );
ParserStack = new ReplParserStack(level);
}
public ActionResult Edit([Bind(Include = "LanguageLevelID,Name")] LanguageLevel languageLevel)
{
if (ModelState.IsValid)
{
db.Entry(languageLevel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(languageLevel));
}
/// <summary>Initializes a new instance of the <see cref="ReplParserStack"/> class configured for the specified language level</summary>
/// <param name="level"><see cref="LanguageLevel"/> for the parser</param>
public ReplParserStack(LanguageLevel level)
{
LanguageLevel = level;
var listener = new FormattedConsoleErrorListener( );
LexErrorListener = listener;
ParseErrorListener = listener;
ErrorStrategy = new ReplErrorStrategy( );
InitializeParser(string.Empty);
}
public ActionResult Edit(LanguageLevel language)
{
if (ModelState.IsValid)
{
_unitOfWork.LanguageLevelRepository.Edit(language);
return(RedirectToAction("Index", "LevelLanguage"));
}
return(View(language));
}
public CodeGenerator(LanguageLevel level)
{
Context = new Context( );
InitializeModuleAndPassManager( );
InstructionBuilder = new InstructionBuilder(Context);
JIT = new KaleidoscopeJIT( );
NamedValues = new Dictionary <string, Alloca>( );
FunctionPrototypes = new PrototypeCollection( );
ParserStack = new ReplParserStack(level);
}
public ActionResult Create([Bind(Include = "LanguageLevelID,Name")] LanguageLevel languageLevel)
{
if (ModelState.IsValid)
{
db.LanguageLevels.Add(languageLevel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(languageLevel));
}
public void Save(LanguageLevel model)
{
if (model.Id > 0)
{
Update(model);
}
else
{
Create(model);
}
}
/// <summary>Initializes a new instance of the <see cref="ReplParserStack"/> class.</summary>
/// <param name="level"><see cref="LanguageLevel"/> for the parser</param>
/// <param name="lexErrorListener">Error listener for Lexer errors</param>
/// <param name="parseErrorListener">Error listener for parer errors</param>
public ReplParserStack(LanguageLevel level
, IAntlrErrorListener <int> lexErrorListener
, IAntlrErrorListener <IToken> parseErrorListener
)
{
LanguageLevel = level;
LexErrorListener = lexErrorListener;
ParseErrorListener = parseErrorListener;
ErrorStrategy = new ReplErrorStrategy( );
InitializeParser(string.Empty);
}
// GET: LanguageLevels/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LanguageLevel languageLevel = db.LanguageLevels.Find(id);
if (languageLevel == null)
{
return(HttpNotFound());
}
return(View(languageLevel));
}
public async Task <LanguageLevel> GetLanguageLevel(int Id)
{
_oLanguageLevel = new LanguageLevel();
using (var httpClient = new HttpClient(_clientHandler))
{
using (var response = await httpClient.GetAsync("https://localhost:44304/api/LanguageLevels/" + Id))
{
string apiResponse = await response.Content.ReadAsStringAsync();
_oLanguageLevel = JsonConvert.DeserializeObject <LanguageLevel>(apiResponse);
}
}
return(_oLanguageLevel);
}
public async Task <ActionResult <CandidateDTO> > GetCandidateDTO(int id)
{
Candidate Candidate = await _context.Candidate.FindAsync(id);
CandidateDTO CandidateDTO = new CandidateDTO();
List <CandidateExperience> candidateExperiences = await _context.CandidateExperience.ToListAsync();
List <CandidateLanguage> candidateLanguages = await _context.CandidateLanguage.ToListAsync();
List <CandidateLanguageDTO> languages = new List <CandidateLanguageDTO>();
foreach (CandidateExperience ca in candidateExperiences)
{
if (ca.CandidateId == id)
{
CandidateDTO.ExperienceId = ca.ExperienceId;
}
}
CandidateDTO.DrivingLicenceId = Candidate.DrivingLicenceId;
CandidateDTO.SalaryWishId = Candidate.SalaryWishId;
foreach (CandidateLanguage cl in candidateLanguages)
{
if (cl.CandidateId == id)
{
CandidateLanguageDTO candidateLanguageDTO = new CandidateLanguageDTO();
candidateLanguageDTO.LanguageId = cl.LanguageId;
candidateLanguageDTO.LanguageLevelId = cl.LanguageLevelId;
Language language = await _context.Language.FindAsync(candidateLanguageDTO.LanguageId);
candidateLanguageDTO.Language = language.Name;
LanguageLevel languageLevel = await _context.LanguageLevel.FindAsync(candidateLanguageDTO.LanguageLevelId);
candidateLanguageDTO.LanguageLevel = languageLevel.Name;
languages.Add(candidateLanguageDTO);
}
}
SalaryWish salary = await _context.SalaryWish.FindAsync(CandidateDTO.SalaryWishId);
DrivingLicence permis = await _context.DrivingLicence.FindAsync(CandidateDTO.DrivingLicenceId);
Experience experience = await _context.Experience.FindAsync(CandidateDTO.ExperienceId);
CandidateDTO.SalaryWish = salary.Salary;
CandidateDTO.DrivingLicence = permis.Type;
CandidateDTO.Experience = experience.Name;
CandidateDTO.Languages = languages;
return(CandidateDTO);
}
public CodeGenerator(LanguageLevel level, TargetMachine machine)
{
LexicalBlocks = new Stack <DIScope>( );
Context = new Context( );
TargetMachine = machine;
InstructionBuilder = new InstructionBuilder(Context);
NamedValues = new Dictionary <string, Alloca>( );
FunctionPrototypes = new PrototypeCollection( );
ParserStack = new ReplParserStack(level);
Module = new BitcodeModule(Context, "Kaleidoscope", SourceLanguage.C, "fib.ks", "Kaleidoscope Compiler")
{
TargetTriple = machine.Triple,
Layout = machine.TargetData
};
DoubleType = new DebugBasicType(Context.DoubleType, Module, "double", DiTypeKind.Float);
}
public JsonResult Get(int id)
{
LanguageLevel model = new LanguageLevel();
try
{
model = this._languageLevelBusiness.GetLanguageLevel(id);
return(Json(model, JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
return(Json(new { responseCode = "-10" }));
}
}
/// <summary>
/// Mapping User Activity Log DTO to Action
/// </summary>
/// <param name=></param>
/// <param name=></param>
/// <returns></returns>
public LanguageLevel MappingLanguageLevelupdateDTOToLanguageLevel(LanguageLevel languageLevel, LanguageLevelUpdateDTO LanguageLevelUpdateDTO)
{
#region Declare Return Var with Intial Value
LanguageLevel LanguageLevel = languageLevel;
#endregion
try
{
if (LanguageLevelUpdateDTO.LanguageLevelId > default(int))
{
LanguageLevel.LanguageLevelId = LanguageLevelUpdateDTO.LanguageLevelId;
LanguageLevel.LanguageLevelName = LanguageLevelUpdateDTO.LanguageLevelName;
}
}
catch (Exception exception) { }
return(LanguageLevel);
}
public async Task <LanguageLevel> PostLanguageLevel(LanguageLevel languageLevel)
{
_oLanguageLevel = new LanguageLevel();
using (var httpClient = new HttpClient(_clientHandler))
{
StringContent content = new StringContent(JsonConvert.SerializeObject(languageLevel), Encoding.UTF8, "application/json");
using (var response = await httpClient.PostAsync("https://localhost:44304/api/LanguageLevels", content))
{
string apiResponse = await response.Content.ReadAsStringAsync();
_oLanguageLevel = JsonConvert.DeserializeObject <LanguageLevel>(apiResponse);
}
}
return(_oLanguageLevel);
}
public bool CreateLanguageLevel(LanguageLevel languageLevel, string userId)
{
try
{
if (!LanguageLevels.Items.Any(x => x.Name == languageLevel.Name.Trim() && x.Level == languageLevel.Level))
{
languageLevel.Name = languageLevel.Name.Trim();
languageLevel.UserCreated = userId;
LanguageLevels.Add(languageLevel);
return(true);
}
}
catch (Exception e)
{
}
return(false);
}
/// <summary>
/// Mapping user Action Actitvity Log
/// </summary>
/// <param name=></ param >
/// <returns>Task<LanguageLevel></returns>
public LanguageLevel MappingLanguageLevelAddDTOToLanguageLevel(LanguageLevelAddDTO LanguageLevelAddDTO)
{
#region Declare a return type with initial value.
LanguageLevel LanguageLevel = null;
#endregion
try
{
LanguageLevel = new LanguageLevel
{
LanguageLevelName = LanguageLevelAddDTO.LanguageLevelName,
CreationDate = DateTime.Now,
IsDeleted = (byte)DeleteStatusEnum.NotDeleted
};
}
catch (Exception exception) { }
return(LanguageLevel);
}
public async Task <int> AddAsync(string cvId, LanguageType languageType,
LanguageLevel comprehension, LanguageLevel speaking, LanguageLevel writing)
{
var languageInfo = new LanguageInfo
{
CurriculumVitaeId = cvId,
LanguageType = languageType,
Comprehension = comprehension,
Speaking = speaking,
Writing = writing
};
await this.repository.AddAsync(languageInfo);
await this.repository.SaveChangesAsync();
return(languageInfo.Id);
}
private void RunBasicReplLoop(LanguageLevel level
, TextReader input
, Func <DynamicRuntimeState, TextWriter, IKaleidoscopeCodeGenerator <Value> > generatorFactory
)
{
var parser = new Parser(level);
using var outputWriter = new TestContextTextWriter(TestContext);
using var generator = generatorFactory(parser.GlobalState, outputWriter);
// Create sequence of parsed AST RootNodes to feed the 'REPL' loop
var replSeq = from stmt in input.ToStatements(_ => { })
select parser.Parse(stmt);
foreach (IAstNode node in replSeq)
{
var errors = node.CollectErrors();
Assert.AreEqual(0, errors.Count( ));
var result = generator.Generate(node);
// Validate guarantees of OptionalValue<T>
Assert.IsTrue((result.HasValue && !(result.Value is null)) || (!result.HasValue && result.Value is null));
if (result.HasValue)
{
switch (result.Value)
{
case ConstantFP value:
TestContext.WriteLine("Evaluated to {0}", value.Value);
break;
case IrFunction function:
TestContext.WriteLine("Generated:\n{0}", function.ToString( ));
break;
default:
TestContext.WriteLine(result.Value !.ToString( ));
break;
}
}
}
}
