public async Task <ActionResult> Create(FormCollection collection)
{
try
{
var newPolicyClient = new PolicyClient
{
ClientId = Convert.ToInt32(TempData["ClientId"]),
PolicyId = Convert.ToInt32(collection["PolicyId"])
};
using (HttpClient httpClient = new HttpClient())
{
var policyClient = JsonConvert.SerializeObject(newPolicyClient);
var data = new StringContent(policyClient, Encoding.UTF8, "application/json");
var url = $"{ConfigurationManager.AppSettings["BaseUrlApi"]}PolicyClients";
var response = await httpClient.PostAsync(url, data);
}
return(RedirectToAction("Details", new { id = TempData["ClientId"] }));
}
catch
{
return(View());
}
}
// GET: PolicyClient/Create
public async Task <ActionResult> Create()
{
using (HttpClient httpClient = new HttpClient())
{
HttpResponseMessage response = await httpClient.GetAsync($"{ConfigurationManager.AppSettings["BaseUrlApi"]}Policies/0");
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
var list = JsonConvert.DeserializeObject <ICollection <Policy> >(json);
var model = new PolicyClient
{
PolicyCollection = list.Select(c => new SelectListItem
{
Value = c.PolicyId.ToString(),
Text = c.Name
}
)
};
return(View(model));
}
else
{
return(View());
}
}
}
public IEnumerable <PolicyClient> Get(PolicyClient entity)
{
List <Models.PolicyClient> policyClients = null;
if (entity == null)
{
policyClients = _context.PolicyClients.ToList();
}
else
{
var query = (from policyCoveragee in _context.PolicyClients.Include(p => p.Policy) select policyCoveragee);
if (entity.PolicyClientId > 0)
{
query = query.Where(c => c.PolicyClientId == entity.PolicyClientId);
}
if (entity.ClientId > 0)
{
query = query.Where(c => c.ClientId == entity.ClientId);
}
if (entity.PolicyId > 0)
{
query = query.Where(c => c.PolicyId == entity.PolicyId);
}
policyClients = query.ToList();
}
return(mapping.Map <IEnumerable <PolicyClient> >(policyClients));
}
public void Update(PolicyClient entity)
{
var updatePolicyClient = mapping.Map <Models.PolicyClient>(entity.PolicyClientId);
updatePolicyClient.Client = null;
updatePolicyClient.Policy = null;
updatePolicyClient.PolicyId = entity.PolicyId;
updatePolicyClient.ClientId = entity.ClientId;
}
public void Create(PolicyClient entity)
{
var newPolicyClient = mapping.Map <Models.PolicyClient>(entity);
newPolicyClient.Client = null;
newPolicyClient.Policy = null;
newPolicyClient.PolicyId = entity.PolicyId;
newPolicyClient.ClientId = entity.ClientId;
_context.PolicyClients.Add(mapping.Map <Models.PolicyClient>(newPolicyClient));
}
/// <summary>
/// CreateOrUpdateInitiative
/// </summary>
/// <param name="initiativeName"></param>
/// <returns></returns>
public async Task CreateOrUpdateInitiative(string initiativeName, PolicySetDefinition policySetDefinition)
{
var serviceCredentials = await _authenticationHelper.GetServiceClientCredentials(ApplicationConstants.RESOURCE_URI.MANAGEMENT);
PolicyClient client = new PolicyClient(serviceCredentials);
string subscriptionid = _appSettings.Subscriptionid;
client.SubscriptionId = subscriptionid;
await client.PolicySetDefinitions.CreateOrUpdateAsync(initiativeName, policySetDefinition);
}
/// <summary>
/// Update policies clients
/// </summary>
/// <param name="policyClient"></param>
/// <returns></returns>
public IHttpActionResult Put([FromBody] PolicyClient policyClient)
{
try
{
_policyClientService.Update(policyClient);
return(Ok());
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
/// <summary>
/// Returns the initiative Details
/// </summary>
/// <param name="initiativeName"></param>
/// <returns></returns>
public async Task <PolicySetDefinition> GetInitiative(string initiativeName)
{
var serviceCredentials = await _authenticationHelper.GetServiceClientCredentials(ApplicationConstants.RESOURCE_URI.MANAGEMENT);
PolicyClient client = new PolicyClient(serviceCredentials);
string subscriptionid = _appSettings.Subscriptionid;
client.SubscriptionId = subscriptionid;
PolicySetDefinition initiative = await client.PolicySetDefinitions.GetAsync(initiativeName);
return(initiative);
}
public async Task <IActionResult> AssingPolicy(int policyId, int clientId)
{
var policyClient = new PolicyClient();
policyClient.PolicyId = policyId;
policyClient.ClientId = clientId;
policyClient.ValidityStarted = DateTime.Now;
_repo.Add(policyClient);
if (await _repo.SaveAll())
{
return(Ok());
}
throw new Exception($"Assing failed on save");
}
public static List <PolicyClient> ToPolicyClient(List <Assigment> lsassigment)
{
List <PolicyClient> lspolicyClients = new List <PolicyClient>();
PolicyClient policyClients = new PolicyClient();
foreach (var item in lsassigment)
{
policyClients = new PolicyClient();
policyClients.ClientId = item.Id;
policyClients.ClientName = item.Name;
policyClients.ClientPhone = item.Phone;
policyClients.PolicyNumber = item.Number;
lspolicyClients.Add(policyClients);
}
return(lspolicyClients);
}
public async Task <string> Assign(PolicyAssignationViewModel model)
{
var policy = unitofWork.PolicyRepository.GetByID(model.IdPolicy);
var client = unitofWork.ClientRepository.GetByID(model.IdClient);
PolicyClient newPolicyCliet = new PolicyClient();
newPolicyCliet.Policy = policy;
newPolicyCliet.Client = client;
unitofWork.PolicyClientRepository.Insert(newPolicyCliet);
var result = await unitofWork.PolicyClientRepository.SaveAsync();
if (result <= 0)
{
throw new Exception("Error creating");
}
else
{
return(null);
}
}
public void SwitchTo(string deviceId, ERole role)
{
if (role != ERole.ERole_enum_count)
{
ComThread.Invoke(() =>
{
if (EnumeratorClient.IsDefault(deviceId, EDataFlow.eRender, role) || EnumeratorClient.IsDefault(deviceId, EDataFlow.eCapture, role))
{
Trace.WriteLine($"Default endpoint already {deviceId}");
return;
}
PolicyClient.SetDefaultEndpoint(deviceId, role);
});
return;
}
SwitchTo(deviceId, ERole.eConsole);
SwitchTo(deviceId, ERole.eMultimedia);
SwitchTo(deviceId, ERole.eCommunications);
}
/// <summary>
/// Assigns the initiative
/// </summary>
/// <param name="initiativeName"></param>
/// <param name="scope"></param>
/// <param name="assignmentName"></param>
/// <returns></returns>
public async Task <PolicyAssignment> AssignInitiative(string initiativeName, string projectCode, string scope, string assignmentName, Tags tags)
{
var serviceCredentials = await _authenticationHelper.GetServiceClientCredentials(ApplicationConstants.RESOURCE_URI.MANAGEMENT);
PolicyClient client = new PolicyClient(serviceCredentials);
string subscriptionid = _appSettings.Subscriptionid;
client.SubscriptionId = subscriptionid;
PolicyAssignment existingAssignment = null;
try
{
existingAssignment = await client.PolicyAssignments.GetAsync(scope, assignmentName);
}
catch (ErrorResponseException) { }
if (existingAssignment != null)
{
await client.PolicyAssignments.DeleteAsync(scope, assignmentName);
}
var initiativeParameters = GetInitiativeParameters(tags, projectCode);
var json = JsonConvert.SerializeObject(initiativeParameters);
var parameters = JObject.Parse(json);
PolicySetDefinition initiative = await client.PolicySetDefinitions.GetAsync(initiativeName);
PolicyAssignment assignment = new PolicyAssignment();
assignment.PolicyDefinitionId = initiative.Id;
assignment.Parameters = parameters;
return(await client.PolicyAssignments.CreateAsync(scope, assignmentName, assignment));
}
public void Delete(PolicyClient entity)
{
var policyClient = _context.PolicyClients.Find(entity.PolicyClientId);
_context.PolicyClients.Remove(policyClient);
}
public void Delete(PolicyClient entity)
{
_unitOfWork.PolicyClient.Delete(entity);
_unitOfWork.Confirm();
}
protected void SetupManagementClients(MockContext context)
{
GuestConfigurationClient = GetGuestConfigurationClient(context);
PolicyClient = GetPolicyClient(context);
_helper.SetupManagementClients(GuestConfigurationClient, PolicyClient);
}
public void Update(PolicyClient entity)
{
_unitOfWork.PolicyClient.Update(entity);
_unitOfWork.Confirm();
}
public IEnumerable <PolicyClient> Get(PolicyClient entity)
{
return(_unitOfWork.PolicyClient.Get(entity));
}
