public async Task <IHttpActionResult> AddUpdateProfessionalBasicDetails(ProfessionalViewModel data)
// public async Task<IHttpActionResult> AddUpdateProfessionalBasicDetails(ProfessionalBasicDetailsViewModel data)
{
ResponseModel <ProfessionalViewModel> Response = new ResponseModel <ProfessionalViewModel>();
ProfessionalViewModel ResponseData = null;
// ResponseModel<ProfessionalBasicDetailsViewModel> Response = new ResponseModel<ProfessionalBasicDetailsViewModel>();
//ProfessionalBasicDetailsViewModel ResponseData = null;
try
{
ProfessionalBasicDetails DBData = _iProfessionalService.SaveProfessionalBasicDetails(data, ref ErrorMessage);
ResponseData = Mapper.Map <ProfessionalBasicDetails, ProfessionalViewModel>(DBData);
//ResponseData = Mapper.Map<ProfessionalBasicDetails, ProfessionalBasicDetailsViewModel>(DBData);
}
catch (Exception Ex) { ErrorMessage = Ex.Message; }
Response = new ResponseModel <ProfessionalViewModel>()
//Response = new ResponseModel<ProfessionalBasicDetailsViewModel>()
{
Response = ResponseData,
Message = ErrorMessage,
ResponseCode = HttpContext.Current.Response.StatusCode,
ResponseDescription = HttpContext.Current.Response.StatusDescription,
SubStatusCode = HttpContext.Current.Response.SubStatusCode
};
return(await Task.FromResult(Content((HttpStatusCode)Response.ResponseCode, Response)));
}
public async Task <IActionResult> EditAccountInfoAsync(string id, ProfessionalViewModel model)
{
ProfessionalViewModel newModel = new ProfessionalViewModel();
ProfessionalModel newProf = new ProfessionalModel();
newProf.Title = model.Professional.Title;
newProf.Location = model.Professional.Location;
newProf.AppointmentLengthInHours = model.Professional.AppointmentLengthInHours;
newProf.HourlyRate = model.Professional.HourlyRate;
newProf.Language = model.Professional.Language;
newProf.Bio = model.Professional.Bio;
newProf.Username = id;
newModel.Professional = newProf;
newModel.Professional.Rating = model.Professional.Rating;
newModel.Username = id;
HttpClientHandler clientHandler = new HttpClientHandler();
var json = JsonConvert.SerializeObject(newProf);
StringContent content = new StringContent(json.ToString());
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return(true); };
HttpClient client = new HttpClient(clientHandler);
var response = await client.PutAsync(apiUrl + apiProfessionalController + "/UpdateProfessional", content);
return(View("ProfessionalAccountView", newModel));
}
public async Task <IActionResult> SetAvailability(string id)
{
ProfessionalViewModel model = new ProfessionalViewModel();
model.Username = id;
return(View("SetAvailability", model));
}
public void Test_ProfessionalViewModelExists()
{
var sut = new ProfessionalViewModel();
ProfessionalViewModel sut1 = new ProfessionalViewModel();
var actual = sut;
Assert.IsType <ProfessionalViewModel>(actual);
Assert.NotNull(actual);
}
public async Task ProfessionalHome_ReturnsAViewResult()
{
var controller = new ProfessionalController();
var user = new ProfessionalViewModel();
var result = await controller.ProfessionalHome(user);
var viewResult = Assert.IsType <ViewResult>(result);
Assert.Null(viewResult.ViewData.Model);
}
public async Task <IActionResult> ProfessionalHome(ProfessionalViewModel model)
{
HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return(true); };
HttpClient client = new HttpClient(clientHandler);
var response = await client.GetAsync(apiUrl + apiProfessionalController + "/GetOneUserByUsername/" + model.Username);
var userModel = JsonConvert.DeserializeObject <UserModel>(await response.Content.ReadAsStringAsync());
return(View("ProfessionalHome", userModel));
}
public async Task <IActionResult> ViewProfile(string id)
{
HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return(true); };
HttpClient client = new HttpClient(clientHandler);
var response = await client.GetAsync(apiUrl + apiProfessionalController + "/GetOneByUsername/" + id);
var professional = JsonConvert.DeserializeObject <ProfessionalModel>(await response.Content.ReadAsStringAsync());
ProfessionalViewModel professionalView = new ProfessionalViewModel();
professionalView.Professional = professional;
professionalView.Username = id;
return(View("ProfessionalAccountView", professionalView));
}
public async Task <IActionResult> LoginAsync([FromBody] LoginViewModel loginUser)
{
IActionResult response = BadRequest();
Professional user = await _unitOfWork.Professional.GetProfessionalProfile(loginUser.UserName);
if (user != null)
{
ProfessionalViewModel userViewModel = _mapper.Map <ProfessionalViewModel>(user);
if (loginUser.Password == user.Password)
{
userViewModel.token = GenerateJSONWebToken(user);
userViewModel.Name = user.Name;
userViewModel.LastName = user.LastName;
response = Ok(userViewModel);
}
}
return(response);
}
/// <summary>
/// Created By Saurabh wanjari
/// Post All Prfessional data
/// </summary>
/// <param name="errorMessage"></param>
/// <returns></returns>
public ProfessionalBasicDetails SaveProfessionalBasicDetails(ProfessionalViewModel data, ref string errorMessage)
{
try
{
ProfessionalBasicDetails DBData = Mapper.Map <ProfessionalViewModel, ProfessionalBasicDetails>(data);
if (DBData.ProfessionalID == "" && DBData.ID == 0)
{
DBData.ProfessionalID = PublicProcedure.GenerateGUID(GUIDExtraction.AlphaNumbers);
DBData.IsDeleted = false;
_professionalBasicDetailsRepo.Add(DBData, ref errorMessage);
}
else
{
ProfessionalBasicDetails SavedData = _professionalBasicDetailsRepo.Get(x => x.ID == DBData.ID, ref errorMessage).FirstOrDefault();
DBData.ProfessionalID = SavedData.ProfessionalID;
DBData.IsDeleted = false;
_professionalBasicDetailsRepo.Update(SavedData, DBData, ref errorMessage);
}
//if (DBData.ProfessionalID != null)
//{
// var ProfessionalData = _professionalBasicDetailsRepo.Get(x => x.ProfessionalID == DBData.ProfessionalID).ToList();
// if (ProfessionalData != null && DBData.ID == 0)
// {
// _professionalBasicDetailsRepo.Add(DBData, ref errorMessage);
// }
// else
// {
// ProfessionalBasicDetails SavedData = _professionalBasicDetailsRepo.Get(x => x.ID == DBData.ID, ref errorMessage).FirstOrDefault();
// _professionalBasicDetailsRepo.Update(SavedData, DBData, ref errorMessage);
// }
//}
//else
//{
// return null;
//}
_unitOfWork.Commit();
return(DBData);
}
catch (Exception Ex) { errorMessage = Ex.Message; }
return(null);
}
public async Task <IHttpActionResult> GetProfessionalBasic(string id)
{
ResponseModel <ProfessionalViewModel> Response = null;
ProfessionalViewModel ReturnObject = null;
long converted_id = Convert.ToInt64(Convert.ToDecimal(id));
long OriginalID = 0;
Byte[] GetByteID = Encoding.ASCII.GetBytes(id);
if (!id.Equals(null))
{
ProfessionalBasicDetails DBData = _iProfessionalService.GetProfessionalBasicDetailByID(converted_id, ref ErrorMessage);
// using (Aes myAes = Aes.Create())
// {
//// Decrypt the string to an array of bytes.
// string decpt = SDHP.Common.PublicProcedure.DecryptStringFromBytes_Aes(GetByteID, myAes.Key, myAes.IV).ToString();
// OriginalID = int.Parse(decpt);
// }
// ProfessionalBasicDetails DBData = _iProfessionalService.GetProfessionalBasicDetailByID(OriginalID, ref ErrorMessage);
if (DBData != null)
{
ReturnObject = Mapper.Map <ProfessionalBasicDetails, ProfessionalViewModel>(DBData);
}
}
else
{
ReturnObject = new ProfessionalViewModel();
}
Response = new ResponseModel <ProfessionalViewModel>()
{
Response = ReturnObject,
Message = ErrorMessage,
ResponseCode = HttpContext.Current.Response.StatusCode,
ResponseDescription = HttpContext.Current.Response.StatusDescription,
SubStatusCode = HttpContext.Current.Response.SubStatusCode
};
return(await Task.FromResult(Content((HttpStatusCode)Response.ResponseCode, Response)));
}
