internal HttpResponseMessage LanguageGenerateCSS(HttpRequestMessage request, LanguageDTO cqDTO)
{
var lr = new LanguageRepository();
var er = new EnglishTermRepository();
var tr = new TranslatedTermRepository();
var lang = lr.GetById(int.Parse(cqDTO.LanguageID));
string cssfilename = lang.CssFileName;
var eTerms = er.GetEnglishTerms();
var tTerms = tr.GetTranslatedTerms(int.Parse(cqDTO.LanguageID));
string retVal = "";
foreach (EnglishTerm eTerm in eTerms)
{
string trans = "";
var tTerm = tTerms.Where(x => x.EnglishTermID == eTerm.EnglishTermID).FirstOrDefault();
if (tTerm != null)
{
trans = tTerm.TermTranslated;
}
retVal += "[data-test='" + eTerm.Term + "']:" + eTerm.BeforeOrAfter + " { content: '" + trans + "';}" + Environment.NewLine;
}
var res = Request.CreateResponse(HttpStatusCode.OK);
res.Content = new StringContent(retVal, Encoding.UTF8, "text/css");
return(res);
}
public void UpdateLanguage(LanguageDTO Language)
{
var entity = Language.ToEntity();
_LanguageRepository.Update(entity);
_CacheManager.Remove(LANGUAGES_ALL_KEY);
}
public IHttpActionResult PutLanguage(int id, LanguageDTO language)
{
//language = new LanguageDTO();
//language.LanguageName = "Hindi";
//language.UserID = 50;
//language.LanguageID = id;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != language.LanguageID)
{
return(BadRequest());
}
try
{
db.Update(language);
}
catch (DbUpdateConcurrencyException)
{
if (!LanguageExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void CreateLanguage(LanguageDTO model)
{
var convertedModel = _mapper.Map <Language>(model);
convertedModel.Added = DateTime.Now;
_genericRepository.Create(convertedModel);
}
public void InsertLanguage(LanguageDTO Language)
{
var entity = Language.ToEntity();
_LanguageRepository.Insert(entity);
Language.Id = entity.Id;
_CacheManager.Remove(LANGUAGES_ALL_KEY);
}
public IActionResult Language([FromBody] LanguageModel model)
{
LanguageDTO dto = Mapping.Mapper.Map <LanguageModel, LanguageDTO>(model);
_curriculumService.AddOrUpdateSectionBlock <LanguageDTO>(dto, model.FormMode, SectionNames.Language);
return(Ok(new { id = model.LanguageId }));
}
internal static Language ToEntity(this LanguageDTO dto)
{
return(new Language()
{
LanguageId = dto.LanguageId,
Name = dto.Name
});
}
public async Task CreateLanguageAsync(LanguageDTO languageDTO)
{
var language = _mapper.Map <LanguageDTO, Language>(languageDTO);
await _languageService.CreateAsync(language);
languageDTO.Id = language.Id;
}
public LanguageDTO Update(LanguageDTO languageDTO)
{
var language = ConverterExtension.ToEntity(languageDTO);
int languageId;
languageId = _languageProvider.Update(language);
return(ConverterExtension.ToDTO(_languageProvider.GetById(languageId)));
}
public LanguageDTO Create(LanguageDTO languageDTO)
{
var category = ConverterExtension.ToEntity(languageDTO);
int newLanguageId = 0;
newLanguageId = _languageProvider.Create(category);
return(ConverterExtension.ToDTO(_languageProvider.GetById(newLanguageId)));
}
private LanguageDTO Resolve(List <String> item)
{
LanguageDTO result = new LanguageDTO();
result.id = int.Parse(item[0]);
result.name = item[1];
return(result);
}
public async void UpdateAsync(LanguageDTO languageDTO)
{
if (await _context.Database.EnsureCreatedAsync())
{
var language = Mapper.Map <LanguageDTO, Language>(languageDTO);
_context.Languages.Update(language);
await _context.SaveChangesAsync();
}
}
public LanguageDTO Create(LanguageDTO modelDTO)
{
if (modelDTO != null)
{
return(LanguageAssembler.ToDTO(LanguagesRepo.Create(LanguageAssembler.ToEntity(modelDTO))));
}
return(null);
}
/// <summary>
/// Convierte el DTO en BM.
/// </summary>
/// <param name="log"></param>
/// <returns></returns>
private LanguageBM ConvertIntoBusinessModel(LanguageDTO entity, List <TranslationBM> translation = null)
{
LanguageBM result = new LanguageBM();
result.Id = entity.id;
result.Name = entity.name;
result.Translations = translation;
return(result);
}
public IActionResult AddLnguage([FromBody] LanguageDTO languageDto)
{
if (languageDto == null)
{
return(BadRequest());
}
var language = _languageManager.Create(languageDto);
return(Created(new Uri("http://localhost:12621/api/language/" + language.LanguageId), language));
}
/// <summary>
/// Devuelve el Business Model del idioma, incluyendo las traducciones asociadas.
/// </summary>
/// <param name="languageId"></param>
/// <returns></returns>
public LanguageBM GetLanguage(int languageId)
{
TranslationBLL translationBll = new TranslationBLL();
List <TranslationBM> translations = translationBll.GetTranslations(languageId);
LanguageDAL languageDal = new LanguageDAL();
LanguageDTO language = languageDal.GetLanguage(languageId);
LanguageBM result = ConvertIntoBusinessModel(language, translations);
return(result);
}
public void Create(LanguageDTO lang)
{
var newLang = new Language
{
Name = lang.Name,
};
_appDB.Languages.Add(newLang);
_appDB.SaveChanges();
}
public void Update(int id, LanguageDTO lang)
{
var oldLang = _appDB.Languages.SingleOrDefault(x => x.Id == id);
if (oldLang != null)
{
oldLang.Name = lang.Name;
_appDB.SaveChanges();
}
}
public IHttpActionResult PostLanguage(LanguageDTO language)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Create(language);
return(CreatedAtRoute("DefaultApi", new { id = language.LanguageID }, language));
}
public void UpdateLanguage(LanguageDTO model)
{
var added = _genericRepository.GetAdded(model.Id);
var convertedModel = _mapper.Map <Language>(model);
convertedModel.Updated = DateTime.Now;
convertedModel.Added = added;
_genericRepository.Update(convertedModel);
}
public IHttpActionResult GetLanguage(int id)
{
LanguageDTO language = db.Get(id);
if (language == null)
{
return(NotFound());
}
return(Ok(language));
}
public async Task <ActionResult> Update(int id, LanguageDTO languageDTO)
{
if (languageDTO.Id != id)
{
BadRequest();
}
await _administrationMicroservice.UpdateLanguageAsync(id, languageDTO);
return(NoContent());
}
public LanguageDTO Update(LanguageDTO modelDTO)
{
LanguageDTO returnLanguage = null;
if (modelDTO != null && modelDTO.LanguageID > 0)
{
LanguagesRepo.Update(0, LanguageAssembler.ToEntity(modelDTO));
returnLanguage = modelDTO;
}
return(returnLanguage);
}
public async Task <IActionResult> ModifyLanguage(int id, [FromBody] LanguageDTO language)
{
if (!ModelState.IsValid)
{
return(BadRequest() as IActionResult);
}
var entity = await service.PutAsync(language);
return(entity == null?StatusCode(304) as IActionResult
: Ok(entity));
}
// POST: Languages
public async Task <IActionResult> AddLanguage([FromBody] LanguageDTO language)
{
if (!ModelState.IsValid)
{
return(BadRequest() as IActionResult);
}
var entity = await service.PostAsync(language);
return(entity == null?StatusCode(409) as IActionResult
: Created($"{Request?.Scheme}://{Request?.Host}{Request?.Path}{entity.Id}",
entity));
}
public ActionResult <LanguageDTO> CreateLanguage(LanguageDTO language)
{
if (String.IsNullOrWhiteSpace(language.Name))
{
return(StatusCode(400));
}
var entity = _mapper.Map <Language>(language);
_languageRepository.Save(entity);
var LanguageDTO = _mapper.Map <LanguageDTO>(_languageRepository.GetById(entity.Id));
return(Ok(_mapper.Map <LanguageDTO>(LanguageDTO)));
}
public LanguageDTO find(string userName, string language)
{
LanguageDTO info = new LanguageDTO();
SqlConnection oConn = new SqlConnection();
SqlCommand sqlCmd = null;
try
{
oConn.ConnectionString = ConfigurationManager.AppSettings["conn"];
oConn.Open();
sqlCmd = oConn.CreateCommand();
sqlCmd.CommandType = CommandType.Text;
sqlCmd.CommandText = "select * from Language where userName = '******' AND languageName = '" + language + "'";
SqlDataReader rdr = sqlCmd.ExecuteReader();
if (rdr.HasRows)
{
while (rdr.Read())
{
info.userName = rdr["userName"].ToString();
info.languageName = rdr["languageName"].ToString();
info.reads = rdr["reads"].ToString();
info.write = rdr["write"].ToString();
info.speak = rdr["speak"].ToString();
}
}
}
catch
{ }
finally
{
if (sqlCmd != null)
{
sqlCmd = null;
}
if (oConn != null)
{
if (oConn.State.Equals(ConnectionState.Open))
{
oConn.Close();
}
oConn = null;
}
}
return info;
}
public LanguageDTO Get(int id)
{
LanguageDTO oLanguageDTO = null;
if (id > 0)
{
Language oLanguage = LanguagesRepo.Get(id);
if (oLanguage != null)
{
oLanguageDTO = LanguageAssembler.ToDTO(oLanguage);
}
}
return(oLanguageDTO);
}
public IHttpActionResult PostLanguage(LanguageDTO language)
{
//language = new LanguageDTO();
//language.LanguageName = "Kan";
//language.UserID = 50;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var objLang = db.Create(language);
return(CreatedAtRoute("DefaultApi", new { id = language.LanguageID }, objLang));
}
public IActionResult UpdateLanguage(int id, [FromBody] LanguageDTO languageDto)
{
if (languageDto == null)
{
return(BadRequest());
}
var languageFromDb = _languageManager.GetById(id);
if (languageFromDb == null)
{
return(BadRequest());
}
var language = _languageManager.Update(languageDto);
return(Ok(language));
}
public async Task <CountryGroupResult> GetCountryGroupsAsync(LanguageDTO language, int pageNo, int pageSize)
{
var localeLangId = language.LanguageId;
var dftLanguageId = int.Parse(_appSettings.Value.DefaultLanguageId);
// By default pick the localLanguage value
var countryGroups = await GetCountryGroupsDataAsync(localeLangId, pageNo, pageSize);
// If localLanguage data is not available then pull the data based on default language
if (countryGroups.CountryGroups.Count == 0)
{
countryGroups = await GetCountryGroupsDataAsync(dftLanguageId, pageNo, pageSize);
}
return(countryGroups);
}
public void LanguageDAOConstructorTest()
{
/*Context*/
LanguageDAO lang_context = new LanguageDAO();
AccountDAO acc_context = new AccountDAO();
/*Insert*/
AccountDTO acc = new AccountDTO();
acc.userName = "******";
acc.password = "******";
acc.accountType = "administrator";
acc.status = "active";
acc_context.presist(acc);
LanguageDTO lang = new LanguageDTO();
lang.userName = "******";
lang.languageName = "english";
lang.speak = "Yes";
lang.write = "Yes";
lang.reads = "Yes";
lang_context.presist(lang);
Assert.AreEqual(lang.speak, lang_context.find("john", "english").speak);
/*Update*/
lang.speak = "No";
lang_context.merge(lang);
Assert.AreEqual("No", lang_context.find("john", "english").speak);
/*Delete*/
lang_context.removeByUserId("john", "english");
Assert.AreEqual(lang_context.isFound("john", "english"), false);
acc_context.removeByUserId("john");
}
public void LanguageDAO_Test()
{
LanguageDAO lang_context = new LanguageDAO();
AccountDAO acc_context = new AccountDAO();
/*Insert*/
AccountDTO acc = new AccountDTO();
acc.userName = "******";
acc.password = "******";
acc.accountType = "administrator";
acc.status = "active";
acc_context.presist(acc);
LanguageDTO lang = new LanguageDTO();
lang.userName = "******";
lang.languageName = "english";
lang.speak = "no";
lang.write = "Yes";
lang.reads = "Yes";
lang_context.presist(lang);
Assert.AreEqual("no", lang_context.find("griddy", "english").speak);
/*Update*/
/*lang.speak = "X";
lang_context.merge(lang);
string str = lang_context.find("griddy", "english").speak;
//Assert.AreEqual("X", str);
/*Delete*/
lang_context.removeByUserId("griddy", "english");
Assert.AreEqual(false, lang_context.isFound("griddy", "english"));
acc_context.removeByUserId("griddy");
}
public bool presist(LanguageDTO entity)
{
bool success = false;
SqlConnection oConn = new SqlConnection();
SqlCommand sqlCmd = null;
try
{
oConn.ConnectionString = ConfigurationManager.AppSettings["conn"];
oConn.Open();
sqlCmd = oConn.CreateCommand();
sqlCmd.CommandType = CommandType.StoredProcedure;
sqlCmd.CommandText = "insertLanguage";
sqlCmd.Parameters.Add(new SqlParameter("userName", entity.userName));
sqlCmd.Parameters.Add(new SqlParameter("languageName", entity.languageName));
sqlCmd.Parameters.Add(new SqlParameter("reads", entity.reads));
sqlCmd.Parameters.Add(new SqlParameter("write", entity.write));
sqlCmd.Parameters.Add(new SqlParameter("speak", entity.speak));
SqlDataReader rdr = sqlCmd.ExecuteReader();
if (rdr.HasRows)
{
while (rdr.Read())
{ } //Read all
}
rdr.Close();
if (rdr.RecordsAffected > 0)
success = true;
}
catch { }
finally
{
if (sqlCmd != null)
{
sqlCmd = null;
}
if (oConn != null)
{
if (oConn.State.Equals(ConnectionState.Open))
{
oConn.Close();
}
oConn = null;
}
}
return success;
}
public void setLanguageDto(LanguageDTO languageDto)
{
view.setLanguage(languageDto.languageName);
view.setRead(languageDto.reads);
view.setWrite(languageDto.write);
view.setSpeak(languageDto.speak);
//view.setUsername(languageInformationDto.userName);
}
public LanguageDTO getLanguageDto()
{
LanguageDTO languageDto = new LanguageDTO();
languageDto.userName = view.getUsername();
languageDto.languageName = view.getLanguage();
languageDto.reads = view.getRead();
languageDto.write = view.getWrite();
languageDto.speak = view.getSpeak();
return languageDto;
}
public bool remove(LanguageDTO entity)
{
return this.removeByUserId(entity.userName, entity.languageName);
}
