/// <summary>
/// Get list gender
/// </summary>
/// <param name="objContex">Get table to object</param>
/// <returns></returns>
public static List <GenderDto> Get(ModelUnibookContainer objContex)
{
try
{
List <GenderDto> genderList = new List <GenderDto>();
foreach (var item in GenderListDal.Get(objContex))
{
GenderDto gender = new GenderDto()
{
Name = item.Name,
GenderId = item.GenderId,
};
genderList.Add(gender);
}
return(genderList);
}
catch (DbEntityValidationException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
}
public void Execute(GenderDto request)
{
var gender = this.Context.Genders.Find(request.Id);
if (gender == null)
{
throw new EntityNotFoundException("gender");
}
if (gender.IsDeleted)
{
throw new EntityNotFoundException("gender");
}
if (gender.Name != request.Name)
{
if (this.Context.Genders.Any(g => g.Name == request.Name))
{
throw new EntityAlreadyExistsException("gender");
}
}
gender.Name = request.Name;
if (gender.IsActive != request.IsActive)
{
gender.IsActive = request.IsActive;
}
gender.ModifiedAt = DateTime.Now;
this.Context.SaveChanges();
}
public async Task <BaseEntity> SaveAndReturnEntityAsync(GenderDto entityDto)
{
var entity = _mapper.Map <Gender>(entityDto);
var result = await _repository.SaveAndReturnEntityAsync(entity);
return(result);
}
public async Task <IActionResult> Edit(GenderDto genderDto)
{
var gender = _mapper.Map <Gender>(genderDto);
var validationResult = _validator.Validate(gender);
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage).ToList();
return(BadRequest(errors));
}
else if (!validationResult.IsValid)
{
var validationErrors = validationResult.Errors.Select(x => $"{x.PropertyName} failed validation: ${x.ErrorMessage}.");
return(BadRequest(string.Join(";", validationErrors)));
}
int result = await _genderRepository.Update(gender).ConfigureAwait(false);
if (result == 1)
{
return(Ok("Gender updated."));
}
return(StatusCode(500, "There was a problem trying to update gender."));
}
public async Task <GenderDto> PostGender(GenderDto model)
{
var url = CRMApiUri + "/Gender";
var result = await PostRequestToApi(url, model);
return(result);
}
public async Task <bool> UpdateGender(GenderDto genderDto)
{
var gender = Mapper.Map <GenderDto, Gender>(genderDto);
UnitOfWork.Repo.Update(gender);
return(await UnitOfWork.SaveChanges() > 0);
}
public async Task <GenderDto> PutGender(int id, GenderDto model)
{
var url = CRMApiUri + "/Gender/" + id;
var result = await PutRequestToApi(url, model);
return(result);
}
public IActionResult CreateGender([FromBody] GenderDto genderDto)
{
if (genderDto == null)
{
return(BadRequest());
}
if (genderRepo.GenderExists(genderDto.GenderName))
{
ModelState.AddModelError("", "Naziv spola vec postoji!");
return(StatusCode(404, ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var genderObj = mapper.Map <Gender>(genderDto);
if (!genderRepo.CreateGender(genderObj))
{
ModelState.AddModelError("", $"Doslo je do greske u spasavanju {genderObj.GenderName}");
return(StatusCode(500, ModelState));
}
return(CreatedAtRoute("GetGender", new { id = genderObj.GenderId }, genderObj));
}
public void Execute(GenderDto request)
{
request.Id = 0;
_validator.ValidateAndThrow(request);
_context.Genders.Add(_maper.Map <Gender>(request));
_context.SaveChanges();
}
/// <summary>
/// Validates the data stored in the Dto being passed through from the Client side
/// </summary>
public bool ValidateRestData(GenderDto gender)
{
var context = new ValidationContext(gender);
var results = new List<ValidationResult>();
return Validator.TryValidateObject(gender, context, results);
}
public async Task <IActionResult> Post([FromBody] GenderDto gender)
{
if (gender.Id != 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Identity insert is not permitted."));
}
return(await SaveAndReturnEntityAsync(async() => await _genderService.SaveAndReturnEntityAsync(gender)));
}
public List <GenderDto> GetAllGender()
{
GenderDto req = new GenderDto();
req.SiteId = 1;
var result = _masterRepository.GetAllGender(req);
return(result);
}
public async Task <IActionResult> Put(int id, [FromBody] GenderDto gender)
{
if (id == 0 || gender.Id == 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Id needs to be greater than 0."));
}
return(await SaveAndReturnEntityAsync(async() => await _genderService.SaveAndReturnEntityAsync(gender)));
}
internal static ServicePoso.Gender? dtoToPosoService(GenderDto? breast)
{
switch (breast)
{
case GenderDto.FEMALE: return ServicePoso.Gender.FEMALE;
case GenderDto.MALE: return ServicePoso.Gender.MALE;
}
return null;
}
internal static VidalAPI.Domain.Gender dtoToNative(GenderDto? breast)
{
switch (breast)
{
case GenderDto.FEMALE: return VidalAPI.Domain.Gender.GENDER_FEMALE;
case GenderDto.MALE: return VidalAPI.Domain.Gender.GENDER_MALE;
}
return VidalAPI.Domain.Gender.GENDER_JNULL;
}
/// <summary>
/// Attempts to add a new gender after ensuring that the data entered is valid
/// </summary>
public async Task <bool> AddNewGender(GenderDto newGender)
{
if (genderLogic.ValidateRestData(newGender))
{
return(await client.InsertGenderAsync(genderLogic.MapToSoap(newGender)));
}
else
{
return(false);
}
}
public async Task <IActionResult> Delete(GenderDto gender)
{
var isDeleted = await _genderBusiness.DeleteGender(gender.Id);
if (isDeleted)
{
return(RedirectToAction("Index"));
}
return(View());
}
/// <summary>
/// Changes the active status of a gender
/// This is essentially the 'Delete' method
/// </summary>
public async Task <bool> DeactivateGender(GenderDto delGender)
{
if (genderLogic.ValidateRestData(delGender))
{
return(await client.DeleteGenderAsync(genderLogic.MapToSoap(delGender)));
}
else
{
return(false);
}
}
public void Execute(GenderDto request)
{
_validator.ValidateAndThrow(request);
var gender = _context.Genders.Find(request.Id);
if (gender == null)
{
throw new EntityNotFoundException(request.Id, typeof(Gender));
}
_maper.Map(request, gender);
_context.SaveChanges();
}
public async Task <IActionResult> Edit(GenderDto gender)
{
if (ModelState.IsValid)
{
var isUpdated = await _genderBusiness.UpdateGender(gender);
if (isUpdated)
{
return(RedirectToAction("Index"));
}
}
return(View(gender));
}
public async Task <IActionResult> UpdateGender([FromBody] GenderDto gender)
{
if (ModelState.IsValid)
{
var isUpdated = await _genderBusiness.UpdateGender(gender);
if (isUpdated)
{
return(Ok("Updated Successfully"));
}
}
return(BadRequest(ModelState));
}
public async Task Update(GenderDto gender)
{
try
{
var itemDb = await _genderRepository.GetAsync(gender.Id);
await _genderRepository.UpdateAsync(ObjectMapper.Map(gender, itemDb));
}
catch (Exception ex)
{
ErrorMessage = L("ErrorAtUpdateInDB") + " [" + ex.Message + "]";
}
}
public List <GenderDto> GetAllGender(GenderDto req)
{
List <GenderDto> lstGender = new List <GenderDto>();
try
{
var Gender = MasterContext.Gender.Where(i => i.SiteId == req.SiteId).ToList();
lstGender = Mapper.Convert <GenderDto, Gender>(Gender);
}
catch (Exception ex)
{
}
return(lstGender);
}
// CRUD
public void Create(GenderDto genderDto, long userId)
{
var gender = Mapper.Map <Gender>(genderDto);
_unitOfWork.GenderRepository.Create(gender);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeCreate,
AppConstants.GenderTableName,
userId,
gender.Id);
}
/// <summary>
/// This is the basic 'Update' method for Instructor
/// </summary>
public async Task <bool> UpdateGender(GenderDto update)
{
if (genderLogic.ValidateRestData(update))
{
var keepStatus = genderLogic.MapToSoap(update);
keepStatus.Active = true;
return(await client.UpdateGenderAsync(keepStatus));
}
else
{
return(false);
}
}
public GenderDto Get(int id)
{
GenderDto genderDto = null;
try
{
genderDto = GenderBrl.GetDto(1, dbcontex);
}
catch (Exception ex)
{
throw ex;
}
return(genderDto);
}
public async Task <HttpResponseMessage> Put([FromBody] GenderDto gender)
{
try
{
var response = Request.CreateResponse(HttpStatusCode.OK, await logic.UpdateGender(gender));
logger.Info("Update gender successful");
return(response);
}
catch (Exception ex)
{
LogHelper.ErrorLogger(logger, ex);
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
public ActionResult Post([FromBody] GenderDto value)
{
try
{
this.insertGenderCommand.Execute(value);
return(StatusCode(201));
}
catch (EntityAlreadyExistsException)
{
return(Conflict());
}
catch (Exception)
{
return(StatusCode(500));
}
}
public void Update(GenderDto genderDto, long userId)
{
var gender = _unitOfWork.GenderRepository.GetById(genderDto.Id);
CommonHelperAppService.MapDtoToEntityForUpdating(genderDto, gender);
_unitOfWork.GenderRepository.Update(gender);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeUpdate,
AppConstants.GenderTableName,
userId,
gender.Id);
}
public IActionResult UpdateGender(int id, [FromBody] GenderDto genderDto)
{
if (genderDto == null || id != genderDto.GenderId)
{
return(BadRequest(ModelState));
}
var genderObj = mapper.Map <Gender>(genderDto);
if (!genderRepo.UpdateGender(genderObj))
{
ModelState.AddModelError("", $"Doslo je do greske u izmjeni {genderObj.GenderName}");
return(StatusCode(500, ModelState));
}
return(NoContent());
}
public void Execute(GenderDto request)
{
if (this.Context.Genders
.Where(g => !g.IsDeleted)
.Any(g => g.Name == request.Name))
{
throw new EntityAlreadyExistsException("gender");
}
this.Context.Genders.Add(new Gender
{
Name = request.Name,
IsActive = request.IsActive
});
this.Context.SaveChanges();
}
public async Task <IActionResult> UpdateGender([FromBody] GenderDto gender)
{
try
{
var isUpdated = await _genderBusiness.UpdateGender(gender);
if (isUpdated)
{
return(Ok("Saved Successfully"));
}
return(NoContent());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public string AnalysisService_patientFromObjToJson(
DateTime dateTime,
GenderDto? gender, int weight, int height, int amen, BreastFeedingDto? breast, int creatin, HepaticInsufficiencyDto? hepatic, List<int> allergiesI, List<int> moleculesI, List<int> cimsI)
{
ServiceAnalysis.ArrayOfInt allergies = new ServiceAnalysis.ArrayOfInt();
foreach(int i in allergiesI){
allergies.Add(i);
}
ServiceAnalysis.ArrayOfInt molecules = new ServiceAnalysis.ArrayOfInt();
foreach (int i in moleculesI)
{
molecules.Add(i);
}
ServiceAnalysis.ArrayOfInt cims = new ServiceAnalysis.ArrayOfInt();
foreach (int i in cimsI)
{
cims.Add(i);
}
return analysisService.patientFromObjToJson(dateTime, GenderDtoHelper.dtoToAnalysisService(gender), weight, height, amen, BreastFeedingDtoHelper.dtoToAnalysisService(breast), creatin, HepaticDtoHelper.dtoToAnalysisService(hepatic), allergies, molecules, cims);
}
public List<NumberOfDosesDto> PosoService_searchDosesByProductId(int productId, GenderDto? gender, float ageF, float weight, int height, int creatin, HepaticInsufficiencyDto? hepatic, List<int> indications, List<int> routes)
{
VidalAPI.Domain.NumberOfDosesList result = vidalProduct.GetService<VidalAPI.Services.PosologyService>().SearchDosesByProductId(productId, GenderDtoHelper.dtoToNative(gender), ageF, weight, height, creatin, HepaticDtoHelper.dtoToNative(hepatic), indications, routes);
return result!=null?NumberOfDosesDtoHelper.vidalToDtoList(result.ToList<VidalAPI.Domain.NumberOfDoses>()):null;
}
public List<string> searchPEAlert(int p, DateTime dateOfBirth, int weight, BreastFeedingDto? breastfeeding, int weeksOfAmenorrhoea, int creatinClearance, GenderDto? gender)
{
IEnumerable<int> productIds = new List<int> { p };
List<string> result = new List<string>();
VidalAPI.Domain.ProductPrecautionEppList ciList = vidalProduct.GetService<VidalAPI.Services.PrecautionService>().SearchByProductIdsAndEpp(productIds, dateOfBirth, weight, BreastFeedingDtoHelper.dtoToNative(breastfeeding), weeksOfAmenorrhoea, creatinClearance, GenderDtoHelper.dtoToNative(gender));
if (ciList != null && ciList.PrecautionEppCouples != null)
{
foreach (VidalAPI.Domain.PrecautionEPPCouple couple in ciList.PrecautionEppCouples)
{
result.Add(couple.Precaution.Name);
result.Add(couple.Epp.ToString());
result.Add(couple.Product.Name);
}
}
if (ciList != null && ciList.Messages != null)
{
foreach (VidalAPI.Domain.Message messega in ciList.Messages)
{
result.Add(messega.MessageType.ToString());
result.Add(messega.Text);
}
}
return result;
}
public string AnalysisService_patientFromObjToJson(DateTime dateTime, GenderDto? gender, int weight, int height, int amen, BreastFeedingDto? breast, int creatin, HepaticInsufficiencyDto? hepatic,List<int> allergies, List<int> molecules, List<int> cims)
{
return vidalProduct.GetService<VidalAPI.Services.DrugPrescriptionAnalysisService>().PatientFromObjToJson(dateTime, GenderDtoHelper.dtoToNative(gender), weight, height, amen, BreastFeedingDtoHelper.dtoToNative(breast), creatin, HepaticDtoHelper.dtoToNative(hepatic), allergies, molecules, cims);
}
public List<NumberOfDosesDto> PosoService_searchDosesByProductId(int productId, GenderDto? gender, float ageF, float weight, int height, int creatin, HepaticInsufficiencyDto? hepatic, List<int>indicationsI, List<int>routesI)
{
ServicePoso.ArrayOfInt indications = new ServicePoso.ArrayOfInt();
foreach (int i in indicationsI)
{
indications.Add(i);
}
ServicePoso.ArrayOfInt routes = new ServicePoso.ArrayOfInt();
foreach (int i in routesI)
{
routes.Add(i);
}
try
{
ServicePoso.NumberOfDoses[] result = posoService.searchDosesByProductId(productId, GenderDtoHelper.dtoToPosoService(gender), ageF, weight, height, creatin, HepaticDtoHelper.dtoToPosoService(hepatic), indications, routes);
return result != null ? NumberOfDosesDtoHelper.vidalToDtoList(result.ToList<ServicePoso.NumberOfDoses>()) : new List<NumberOfDosesDto>();
}
catch (Exception)
{ return null; }
}
public List<string> searchPEAlert(int p, DateTime dateOfBirth, int weight, BreastFeedingDto? breastfeeding, int weeksOfAmenorrhoea, int creatinClearance, GenderDto? gender)
{
return new List<string>(); //todo ;
}
