private void ValidateSaveApiClient(ApiClientModel model)
{
var keyExist = _apiClientBusiness.DoesKeyExist(model.ApiClientId, model.Key);
if (keyExist)
{
Error = string.Format("Api Client {0} could not be saved because the key '{1}' already exists.", model.Name, model.Key);
return;
}
var nameExist = _apiClientBusiness.DoesNameExist(model.ApiClientId, model.Name);
if (nameExist)
{
Error = string.Format("Api Client {0} could not be saved because the name '{0}' already exists.", model.Name);
}
if (model.SecretDisplay != Domain.SecretDisplayConstant.SecretDisplayHashed)
{
if (model.SecretDisplay.Trim().Length < 16)
{
Error = string.Format("Api Client {0} could not be saved because the secret must be at least 16 characters.", model.Name);
return;
}
if (model.SecretDisplay.Trim() == model.Key)
{
Error = string.Format("Api Client {0} could not be saved because the secret must not match the key.", model.Name);
return;
}
if (model.SecretDisplay.Trim() == model.Name)
{
Error = string.Format("Api Client {0} could not be saved because the secret must not match the name.", model.Name);
return;
}
}
}
public ActionResult DeleteConfirmed(int id)
{
ApiClientModel apiClientModel = db.ApiClientModels.Find(id);
db.ApiClientModels.Remove(apiClientModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public HttpResponseMessage Delete(ApiClientModel client)
{
if (_clientManager.Delete(client))
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
public ActionResult AddInsurance(ApiInsuranceModel apiInsurance, ApiClientModel apiClient, ApiDocumentModel apiDocument, ApiPolicyCoverageDetailModel apiPolicyCoverageDetail, ApiCoverageModel apiCoverage)
{
ApiInsuranceModel insurance = new ApiInsuranceModel
{
ID = apiInsurance.ID,
Joining_Date = apiInsurance.Joining_Date,
End_Date = apiInsurance.End_Date,
Total_Value = apiInsurance.Total_Value,
InsuranceType = apiInsurance.InsuranceType,
AgentID = apiInsurance.AgentID,
Client = new ApiClientModel
{
ID = apiClient.ID,
First_Name = apiClient.First_Name,
Middle_Name = apiClient.Middle_Name,
Last_Name = apiClient.Middle_Name,
Age = apiClient.Age,
Address = apiClient.Address,
Date_of_Birth = apiClient.Date_of_Birth,
Gender = apiClient.Gender,
Nationality = apiClient.Nationality,
Religion = apiClient.Religion,
BloodGroup = apiClient.BloodGroup,
Email = apiClient.Email,
Mobile = apiClient.Mobile,
Telephone = apiClient.Mobile,
},
Documents = new ApiDocumentModel
{
ID = apiDocument.ID,
InsuranceID = apiDocument.InsuranceID,
Authuorization = apiDocument.Authuorization,
Document = apiDocument.Document,
},
PolicyDetails = new ApiPolicyCoverageDetailModel
{
ID = apiPolicyCoverageDetail.ID,
CoverageValue = apiPolicyCoverageDetail.CoverageValue,
TotalPolicyValue = apiPolicyCoverageDetail.TotalPolicyValue,
Note = apiPolicyCoverageDetail.Note,
InsuranceID = apiPolicyCoverageDetail.InsuranceID,
CoverageID = apiPolicyCoverageDetail.CoverageID,
},
Coverage = new ApiCoverageModel
{
ID = apiCoverage.ID,
CoverageType = apiCoverage.CoverageType,
Includes = apiCoverage.Includes,
conditions = apiCoverage.conditions,
},
};
return(View());
}
public JsonResult ApiClient_Create2(ApiClientModel model)
{
if (model != null && ModelState.IsValid)
{
try
{
ValidateSaveApiClient(model);
if (!string.IsNullOrWhiteSpace(model.Errors))
{
return(Json(new
{
success = false,
Errors = string.Format("Could not create api client {0} : {1} ", model.Name, model.Errors)
}));
}
var client = new ApiClient
{
Key = model.Key,
Secret = model.SecretDisplay,
Name = model.Name,
ApplicationApplicationId = model.ApplicationApplicationId
};
_apiClientBusiness.Create(WamsUser.WamsId, client);
_apiClientBusiness.SaveChanges(WamsUser.WamsId);
model.ApiClientId = client.ApiClientId;
}
catch (Exception)
{
return(Json(new
{
success = false,
Errors = string.Format("Could not create api client {0} ", model.Name)
}));
}
}
else
{
if (model != null)
{
var errorList = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
model.Errors = string.Join("<br /> ", errorList);
return(Json(new
{
success = false,
Errors = string.Format("Could not create api client {0} : {1}", model.Name, model.Errors)
}));
}
}
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
public ActionResult Edit([Bind(Include = "ID,First_Name,Middle_Name,Last_Name,Age,Address,Date_of_Birth,Gender,Nationality,Religion,BloodGroup,Email,Mobile,Telephone")] ApiClientModel apiClientModel)
{
if (ModelState.IsValid)
{
db.Entry(apiClientModel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(apiClientModel));
}
public JsonResult ApiClient_Update2(ApiClientModel model)
{
if (model != null && ModelState.IsValid)
{
try
{
ValidateSaveApiClient(model);
if (HasErrors)
{
return(Json(new
{
success = false,
Errors = string.Format("Could not update Client {0} : {1}", model.Name, model.Errors)
}));
}
var client = _apiClientBusiness.GetApiClient(model.ApiClientId);
client.Key = model.Key;
if (model.SecretDisplay != Domain.SecretDisplayConstant.SecretDisplayHashed)
{
client.Secret = model.SecretDisplay;
client.SecretIsHashed = false;
}
client.Name = model.Name;
client.IsApproved = model.IsApproved;
client.UseSandbox = model.UseSandbox;
client.SandboxType = model.SandboxType;
client.UserUserId = model.UserUserId;
if (client.ApplicationApplicationId != model.ApplicationApplicationId)
{
var application =
_applicationBusiness.GetApplicationById(model.ApplicationApplicationId.GetValueOrDefault());
client.ApplicationApplicationId = model.ApplicationApplicationId;
foreach (var clientApplicationEducationOrganization in client.ApplicationEducationOrganizations.Where(e => e.Application.VendorVendorId == application.VendorVendorId))
{
clientApplicationEducationOrganization.ApplicationApplicationId =
model.ApplicationApplicationId;
}
}
_apiClientBusiness.Update(WamsUser.WamsId, client);
_apiClientBusiness.SaveChanges(WamsUser.WamsId);
}
catch (Exception)
{
return(Json(new
{
success = false,
Errors = string.Format("Could not update Client {0}", model.Name)
}));
}
}
return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
}
public ActionResult ApiClient_Create2(int applicationId)
{
var model = new ApiClientModel
{
ApplicationApplicationId = applicationId,
Secret = Guid.NewGuid().ToString()
};
model.SecretDisplay = model.Secret;
return(PartialView("_ApiClient", model));
}
public HttpResponseMessage Post(ApiClientModel client)
{
APIModelMapper apiModelMapper = new APIModelMapper();
ClientModel model = apiModelMapper.MapClientModel(client);
if (_clientManager.Record(model))
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
// GET: ApiClientModels/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ApiClientModel apiClientModel = db.ApiClientModels.Find(id);
if (apiClientModel == null)
{
return(HttpNotFound());
}
return(View(apiClientModel));
}
public ActionResult ApiClient_Update2(int apiClientId)
{
var client = _apiClientBusiness.GetApiClient(apiClientId);
var apiClientModel = new ApiClientModel
{
ApiClientId = client.ApiClientId,
Name = client.Name,
Key = client.Key,
Secret = client.Secret,
SecretIsHashed = client.SecretIsHashed,
ApplicationApplicationId = client.ApplicationApplicationId,
SecretDisplay = client.SecretDisplay
};
return(PartialView("_ApiClient", apiClientModel));
}
public ClientModel MapClientModel(ApiClientModel client)
{
return(new ClientModel()
{
ID = client.ID,
First_Name = client.First_Name,
Last_Name = client.Last_Name,
Address = client.Address,
Date_of_Birth = client.Date_of_Birth,
Age = client.Age,
BloodGroup = (ClientModel.BloodGroups)client.BloodGroup,
Email = client.Email,
Gender = (ClientModel.Genders)client.Gender,
Middle_Name = client.Middle_Name,
Mobile = client.Mobile,
Nationality = client.Nationality,
Religion = client.Religion,
Telephone = client.Telephone
});
}
public ApiInsuranceModel Get(String insuranceId)
{
/* ApiInsuranceModel insurance = new ApiInsuranceModel
* {
* //ID = (int)ID,
* //AgentID = 1,
* //ClientID = 1,
* //Joining_Date = new DateTime(2000, 02, 29),
* //End_Date = new DateTime(2017, 02, 29),
* //Total_Value = 1000000,
* };
*
* return insurance;*/
InsuranceModel selectedInsurance = _insuranceManager.Find <InsuranceModel>(e => e.ID.Equals(insuranceId));
ClientModel clientModel = _insuranceManager.Find <ClientModel>(e => e.ID.Equals(selectedInsurance.ID));
DocumentModel document = _insuranceManager.Find <DocumentModel>(e => e.InsuranceID.Equals(selectedInsurance.ID));
PolicyCoverageDetailModel pcd = _insuranceManager.Find <PolicyCoverageDetailModel>(e => e.InsuranceID.Equals(selectedInsurance.ID));
CoverageModel coverage = _insuranceManager.Find <CoverageModel>(e => e.ID.Equals(pcd.CoverageID));
CommonToApiModelMapper mapper = new CommonToApiModelMapper();
ApiInsuranceModel mapped = new ApiInsuranceModel();
if (selectedInsurance.InsuranceType.Equals(InsuranceModel.InsuranceTypes.LIFE_INSURANCE))
{
LifeInsuranceModel life = _insuranceManager.Find <LifeInsuranceModel>(e => e.ClientID.Equals(selectedInsurance.ClientID));
ApiLifeInsuranceModel apiLifeInsuranceModel = mapper.MapLifeInsuranceCommonModel(life);
mapped.SelectedInsurance = apiLifeInsuranceModel;
}
ApiClientModel apiCLient = mapper.MapClientCommonModel(clientModel);
ApiDocumentModel apiDoc = mapper.MapDocumentCommonModel(document);
ApiPolicyCoverageDetailModel apiPcd = mapper.MapPolicyCoverageDetailCommonModel(pcd);
ApiCoverageModel apiCoverage = mapper.MapCoverageCommonModel(coverage);
mapped.Client = apiCLient;
mapped.Coverage = apiCoverage;
mapped.Documents = apiDoc;
mapped.PolicyDetails = apiPcd;
return(mapped);
}
