public async Task <HttpResponseMessage> ReadDocument(Guid id)
{
var document = await DataContext.NetworkRequestDocuments.FindAsync(id);
if (document == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Document not found."));
}
var networkDetails = await(from rsp in DataContext.NetworkRequestResponses
let network = rsp.NetworkRequestRoute.Participant.NetworkRequest.Network
where rsp.ID == document.ResponseID
select new
{
NetworkID = network.ID,
network.ServiceUrl,
network.ServiceUserName,
network.ServicePassword
}).FirstOrDefaultAsync();
using (var pmnAPI = new Lpp.Dns.ApiClient.DnsClient(networkDetails.ServiceUrl, networkDetails.ServiceUserName, Lpp.Utilities.Crypto.DecryptString(networkDetails.ServicePassword)))
{
return(await pmnAPI.Documents.Read(document.SourceDocumentID));
}
}
public async Task <NetworkRequestTypeDefinitionDTO> GetRequestTypeDefinition(Guid id)
{
var definition = await DataContext.NetworkRequestTypeDefinitions.Where(rt => rt.ID == id)
.Select(rt => new
{
DTO = new NetworkRequestTypeDefinitionDTO
{
ID = rt.ID,
NetworkID = rt.NetworkID,
Network = rt.Network.Name,
ProjectID = rt.ProjectID,
RequestTypeID = rt.RequestTypeID,
DataSourceID = rt.DataSourceID,
DataSource = rt.DataSource.Name,
Timestamp = rt.Timestamp
},
NetworkSettings = new { rt.Network.ServiceUrl, rt.Network.ServiceUserName, rt.Network.ServicePassword }
})
.FirstOrDefaultAsync();
if (definition == null)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, "A requesttype definition was not found for the specified ID."));
}
using (var pmnAPI = new Lpp.Dns.ApiClient.DnsClient(definition.NetworkSettings.ServiceUrl, definition.NetworkSettings.ServiceUserName, Utilities.Crypto.DecryptString(definition.NetworkSettings.ServicePassword)))
{
var project = await pmnAPI.Projects.Get(definition.DTO.ProjectID);
var requestType = await pmnAPI.RequestTypes.Get(definition.DTO.RequestTypeID);
definition.DTO.Project = project == null ? UnableToDetermineMessage : project.Name;
definition.DTO.RequestType = requestType == null ? UnableToDetermineMessage : requestType.Name;
}
return(definition.DTO);
}
public async Task <IEnumerable <NetworkRequestTypeDefinitionDTO> > ListRequestTypeDefinitions()
{
var definitions = await DataContext.NetworkRequestTypeDefinitions.Select(d => new NetworkRequestTypeDefinitionDTO {
ID = d.ID, NetworkID = d.NetworkID, Network = d.Network.Name, ProjectID = d.ProjectID, RequestTypeID = d.RequestTypeID, DataSourceID = d.DataSourceID, DataSource = d.DataSource.Name, Timestamp = d.Timestamp
}).ToArrayAsync();
var networkIDs = definitions.Select(n => n.NetworkID).Distinct().ToArray();
var networks = await DataContext.Networks.AsNoTracking()
.Where(n => networkIDs.Contains(n.ID))
.Select(n => new { n.ID, n.ServiceUrl, n.ServicePassword, n.ServiceUserName })
.ToArrayAsync();
//get the project and requestType names for each combination
foreach (var networkGrouping in definitions.GroupBy(k => k.NetworkID))
{
var network = networks.FirstOrDefault(n => n.ID == networkGrouping.Key);
using (var pmnAPI = new Lpp.Dns.ApiClient.DnsClient(network.ServiceUrl, network.ServiceUserName, Utilities.Crypto.DecryptString(network.ServicePassword)))
{
string odataFilter = "$filter=" + string.Join(" or ", networkGrouping.Select(n => n.ProjectID).Distinct().Select(id => string.Format("ID eq {0:D}", id)));
var pmnProjects = await pmnAPI.Projects.List(odataFilter);
odataFilter = "$filter=" + string.Join(" or ", networkGrouping.Select(n => n.RequestTypeID).Distinct().Select(id => string.Format("ID eq {0:D}", id)));
var pmnRequestTypes = await pmnAPI.RequestTypes.List(odataFilter);
foreach (var definition in networkGrouping)
{
definition.Project = pmnProjects.Where(p => p.ID == definition.ProjectID).Select(p => p.Name).FirstOrDefault() ?? UnableToDetermineMessage;
definition.RequestType = pmnRequestTypes.Where(rt => rt.ID == definition.RequestTypeID).Select(rt => rt.Name).FirstOrDefault() ?? UnableToDetermineMessage;
}
}
}
return(definitions.OrderBy(d => d.Network).ThenBy(d => d.Project).ThenBy(d => d.RequestType).ThenBy(d => d.DataSource));
}
public async Task <IEnumerable <NetworkRequestTypeMappingDTO> > ListMappings()
{
var mappings = await(from nm in DataContext.NetworkRequestTypeMappings
select new NetworkRequestTypeMappingDTO {
ID = nm.ID,
NetworkID = nm.NetworkID,
Network = nm.Network.Name,
ProjectID = nm.ProjectID,
RequestTypeID = nm.RequestTypeID,
Timestamp = nm.Timestamp,
Routes = nm.NetworkRoutes.Select(rt => new NetworkRequestTypeDefinitionDTO {
ID = rt.RequestTypeDefinition.ID,
NetworkID = rt.RequestTypeDefinition.NetworkID,
Network = rt.RequestTypeDefinition.Network.Name,
ProjectID = rt.RequestTypeDefinition.ProjectID,
RequestTypeID = rt.RequestTypeDefinition.RequestTypeID,
DataSourceID = rt.RequestTypeDefinition.DataSourceID,
DataSource = rt.RequestTypeDefinition.DataSource.Name,
Timestamp = rt.RequestTypeDefinition.Timestamp
})
}).ToArrayAsync();
if (mappings.Length == 0)
{
return(Array.Empty <NetworkRequestTypeMappingDTO>());
}
//get the distinct network/project/requesttype definitions
var networkProjectRequestTypes = mappings.Select(m => new { m.NetworkID, m.ProjectID, m.RequestTypeID })
.Concat(mappings.SelectMany(m => m.Routes.Select(r => new { r.NetworkID, r.ProjectID, r.RequestTypeID })))
.GroupBy(k => new { k.NetworkID, k.ProjectID, k.RequestTypeID })
.Select(g => new NetworkRequestTypeDefinitionDTO {
NetworkID = g.Key.NetworkID,
ProjectID = g.Key.ProjectID,
RequestTypeID = g.Key.RequestTypeID
})
.ToArray();
var networkIDs = networkProjectRequestTypes.Select(n => n.NetworkID).Distinct().ToArray();
var networks = await DataContext.Networks.AsNoTracking()
.Where(n => networkIDs.Contains(n.ID))
.Select(n => new { n.ID, n.ServiceUrl, n.ServicePassword, n.ServiceUserName })
.ToArrayAsync();
//get the project and requestType names for each combination
foreach (var nprt in networkProjectRequestTypes.GroupBy(k => k.NetworkID))
{
var network = networks.FirstOrDefault(n => n.ID == nprt.Key);
using (var pmnAPI = new Lpp.Dns.ApiClient.DnsClient(network.ServiceUrl, network.ServiceUserName, Utilities.Crypto.DecryptString(network.ServicePassword)))
{
string odataFilter = "$filter=" + string.Join(" or ", nprt.Select(n => n.ProjectID).Distinct().Select(id => string.Format("ID eq {0:D}", id)));
var pmnProjects = await pmnAPI.Projects.List(odataFilter);
odataFilter = "$filter=" + string.Join(" or ", nprt.Select(n => n.RequestTypeID).Distinct().Select(id => string.Format("ID eq {0:D}", id)));
var pmnRequestTypes = await pmnAPI.RequestTypes.List(odataFilter);
foreach (var definition in nprt)
{
definition.Project = pmnProjects.Where(p => p.ID == definition.ProjectID).Select(p => p.Name).FirstOrDefault() ?? UnableToDetermineMessage;
definition.RequestType = pmnRequestTypes.Where(rt => rt.ID == definition.RequestTypeID).Select(rt => rt.Name).FirstOrDefault() ?? UnableToDetermineMessage;
}
}
}
var projectRequestTypeDetailsMap = networkProjectRequestTypes.ToDictionary(k => string.Format("{0:D}-{1:D}-{2:D}", k.NetworkID, k.ProjectID, k.RequestTypeID));
string key;
//update the mapping dto details
foreach (var map in mappings)
{
key = string.Format("{0:D}-{1:D}-{2:D}", map.NetworkID, map.ProjectID, map.RequestTypeID);
NetworkRequestTypeDefinitionDTO detail;
if (projectRequestTypeDetailsMap.TryGetValue(key, out detail))
{
map.Project = detail.Project ?? UnableToDetermineMessage;
map.RequestType = detail.RequestType ?? UnableToDetermineMessage;
}
else
{
map.Project = UnableToDetermineMessage;
map.RequestType = UnableToDetermineMessage;
}
foreach (var def in map.Routes)
{
key = string.Format("{0:D}-{1:D}-{2:D}", def.NetworkID, def.ProjectID, def.RequestTypeID);
if (projectRequestTypeDetailsMap.TryGetValue(key, out detail))
{
def.Project = detail.Project ?? UnableToDetermineMessage;
def.RequestType = detail.RequestType ?? UnableToDetermineMessage;
}
else
{
def.Project = UnableToDetermineMessage;
def.RequestType = UnableToDetermineMessage;
}
}
map.Routes = map.Routes.OrderBy(r => r.Network).ThenBy(r => r.Project).ThenBy(r => r.RequestType).ThenBy(r => r.DataSource);
}
mappings = mappings.OrderBy(m => m.Network).ThenBy(m => m.Project).ThenBy(m => m.RequestType).ToArray();
return(mappings);
}
public async Task <ActionResult> Login(string username, string password, string returnUrl)
{
if (Auth.CurrentUser != null)
{
return(Redirect(string.IsNullOrWhiteSpace(returnUrl) ? "~/" : returnUrl));
}
using (var client = new Lpp.Dns.ApiClient.DnsClient(WebConfigurationManager.AppSettings["ServiceUrl"]))
{
UserDTO contact = null;
try
{
contact = await client.Users.ValidateLogin(new Lpp.Dns.DTO.LoginDTO
{
UserName = username,
Password = password,
IPAddress = HttpContext.Request.UserHostAddress,
Enviorment = "Portal"
});
}
catch (Exception ex)
{
string msg = "";
int i = 0;
while (i < ex.Message.Length && !ex.Message[i].Equals(';'))
{
msg = msg + ex.Message[i];
i++;
}
ModelState.AddModelError("Error", msg);
}
if (!ModelState.IsValid)
{
return(View("~/Views/Home/Login.cshtml", new LoginModel {
ReturnUrl = returnUrl
}));
}
User user = await DataContext.Users.FindAsync(contact.ID);
Auth.SetCurrentUser(user, AuthenticationScope.WebSession);
var expireMinutes = WebConfigurationManager.AppSettings["SessionExpireMinutes"];
if (string.IsNullOrWhiteSpace(expireMinutes))
{
expireMinutes = "30";
}
var sModel = Newtonsoft.Json.JsonConvert.SerializeObject(new LoginResponseModel(user, password, user.OrganizationID, user.PasswordExpiration, Convert.ToInt32(expireMinutes)));
var authCookie = new HttpCookie("Authorization", sModel)
{
Shareable = false,
Expires = DateTime.MinValue,
};
Response.Cookies.Add(authCookie);
return(Redirect(string.IsNullOrWhiteSpace(returnUrl) ? "~/" : returnUrl));
}
}
