public ActionResult Thread(string id, string issueThread)
{
if (id == null)
{
throw new ArgumentNullException("id", "InitiativeId was not provided.");
}
var i = _initiativeBusiness.GetInitiatives().Where(x => x.Name == id).ToArray();
var initiativeId = Guid.Empty;
if (i.Count() == 1)//Name is unique
{
initiativeId = _initiativeBusiness.GetInitiatives().Single(x => x.Name == id).Id;
}
else//go with id
{
initiativeId = _initiativeBusiness.GetInitiatives().Single(x => x.Id == Guid.Parse(id)).Id;
}
if (initiativeId == Guid.Empty)
{
throw new NullReferenceException("No initiative found for the specified uid.");
}
var initiative = _initiativeBusiness.GetInitiative(initiativeId);
var applicationIds = initiative.ApplicationGroups.SelectMany(x => x.Applications).Select(x => x.Id).ToArray();
var versions = new List <IApplicationVersion>();
foreach (var applicationId in applicationIds)
{
versions.AddRange(_applicationVersionBusiness.GetApplicationVersions(applicationId));
}
var issues = versions.SelectMany(x => x.IssueTypes).SelectMany(x => x.Issues).Where(x => x.IssueThreadGuid == Guid.Parse(issueThread)).ToArray();
var sessions = _sessionBusiness.GetSessionsForApplications(applicationIds).ToArray();
var users = sessions.Select(x => _userBusiness.GetUser(x.UserFingerprint));
var model = new IssueThreadModel()
{
InitiativeUniqueIdentifier = id,
InitiativeName = initiative.Name,
Issues = issues,
Sessions = sessions,
Users = users,
};
return(View(model));
}
public ActionResult Details(string applicationVersionId, string sessionId)
{
var session = _sessionBusiness.GetSessionsForApplicationVersion(applicationVersionId).Single(x => x.Id == Guid.Parse(sessionId));
var version = _applicationVersionBusiness.GetApplicationVersions(session.ApplicationId).Single(x => x.Id == applicationVersionId);
return(View(version.IssueTypes));
}
// GET: Application/Details/5
public ActionResult Details(string id, string application)
{
if (id == null)
{
throw new ArgumentNullException("id", "No initiative id provided.");
}
var initiative = _initiativeBusiness.GetInitiative(_accountRepository.FindById(User.Identity.GetUserId()).Email, id);
var app = initiative.ApplicationGroups.SelectMany(x => x.Applications).Single(x => x.Name == application);
var versions = _applicationVersionBusiness.GetApplicationVersions(app.Id).ToArray();
var model = GetApplicationModel(initiative, application, versions);
@ViewBag.IsArchive = false;
@ViewBag.Title = "Application Details";
@ViewBag.SiteRoot = GetSiteRoot();
return(View(model));
}
// GET: Version/Details/5
public ActionResult Details(string id, string application, string version)
{
var initiative = _initiativeBusiness.GetInitiative(_accountRepository.FindById(User.Identity.GetUserId()).Email, id);
var applicationId = initiative.ApplicationGroups.SelectMany(x => x.Applications).Single(x => x.Name == application).Id;
var versions = _applicationVersionBusiness.GetApplicationVersions(applicationId).ToArray();
var versionName = _applicationVersionBusiness.GetApplicationVersion(initiative.Id.ToString(), applicationId.ToString(), version).Version;
//var versionIds = versions.Select(v => v.Id).ToArray();
//change to EnvironmentViewModel when fixed
//var environments = new List<string>();
//foreach (var versionId in versionIds)
//{
// environments.Add(_sessionBusiness.GetSessionsForApplicationVersion(versionId).Select(x => x.Environment));
//}
var ver = versions.Single(x => x.Id.Replace(":", "") == version || x.Version == version);
//var sessions = _sessionBusiness.GetSessionsForApplicationVersion();
var issue = new IssueViewModel
{
InitiativeId = initiative.Id.ToString(),
InitiativeName = initiative.Name,
ApplicationName = application,
Version = version,
VersionName = versionName,
IssueTypes = ver.IssueTypes,
Sessions = _sessionBusiness.GetSessionsForApplicationVersion(ver.Id),
ApplicationVersionId = applicationId.ToString(),
InitiativeUniqueIdentifier = id,
};
var allEnvironments = _initiativeBusiness.GetEnvironmentColors(User.Identity.GetUserId(), _accountRepository.FindById(User.Identity.GetUserId()).UserName);
var envs = issue.Sessions.Select(x => x.Environment).Distinct();
var environments = new List <EnvironmentViewModel>();
foreach (var environment in envs)
{
if (allEnvironments.ContainsKey(environment))
{
string color;
allEnvironments.TryGetValue(environment, out color);
environments.Add(new EnvironmentViewModel()
{
Name = environment,
Color = color,
});
}
}
//issue.Environments = environments.Select(x => new EnvironmentViewModel { Name = x.Key, Color = x.Value}).ToList();
issue.Environments = environments;
issue.UniqueIdentifier = issue.GetUniqueIdentifier(versionName);
//issue.ExceptionTypeName = ver.IssueTypes.Select(x => x.ExceptionTypeName);
//issue.Message = ver.IssueTypes.Select(x => x.Message);
//issue.Level = ver.IssueTypes.Select(x => x.IssueLevel.ToString());
//issue.Count = ver.IssueTypes.Select(x => x.Count.ToString());
//issue.Ticket = ver.IssueTypes.Select(x => x.Ticket.ToString());
var users = issue.Sessions.Select(user => _userBusiness.GetUser(user.UserFingerprint)).ToList().GroupBy(x => x.Id).Select(x => x.First());
issue.Users = users;
issue.Machines = _machineBusiness.GetMachinesByApplicationVersion(ver.Id);
return(View(issue));
}
public ActionResult SearchResults(string searchText)
{
var model = new SearchModel()
{
IsConfirmed = _accountRepository.GetUser(_accountRepository.FindById(User.Identity.GetUserId()).Email).EMailConfirmed,
SearchText = searchText,
};
if (!model.IsConfirmed)
{
return(View("SearchResults", model));
}
var searchResultRows = new List <SearchResultRowModel>();
var initiativeHeads = _initiativeBusiness.GetInitiativesByDeveloper(_accountRepository.FindById(User.Identity.GetUserId()).Email);
var initiatives = _initiativeBusiness.GetInitiatives().ToArray();
var userInitiatives = initiativeHeads.Select(initiativeHead => initiatives.Single(x => x.Id == initiativeHead.Id)).ToArray();
foreach (var initiative in userInitiatives)
{
var applications = initiative.ApplicationGroups.SelectMany(x => x.Applications).ToArray();
var initiativeUniqueIdentifier = initiative.GetUniqueIdentifier(initiatives.Select(x => x.Name));
var versions = new List <IApplicationVersion>();
foreach (var application in applications)
{
versions.AddRange(_applicationVersionBusiness.GetApplicationVersions(application.Id));
}
foreach (var version in versions)
{
foreach (var issueType in version.IssueTypes)
{
if (issueType.Ticket.ToString().Equals(searchText))
{
foreach (var issue in issueType.Issues)
{
searchResultRows.Add(new SearchResultRowModel()
{
InitiativeName = initiative.Name,
InitiativeUniqueIdentifier = initiativeUniqueIdentifier,
ApplicationName = applications.Single(x => x.Id == version.ApplicationId).Name,
Version = version.Version,
VersionUniqueIdentifier = version.GetUniqueIdentifier(versions.Select(x => x.Version)),
IssueType = issueType,
Issue = issue,
Environment = GetSession(issue.SessionId).Environment,
});
}
}
else
{
foreach (var issue in issueType.Issues)
{
if (issue.Ticket.ToString().Equals(searchText))
{
searchResultRows.Add(new SearchResultRowModel()
{
InitiativeName = initiative.Name,
InitiativeUniqueIdentifier = initiativeUniqueIdentifier,
ApplicationName = applications.Single(x => x.Id == version.ApplicationId).Name,
Version = version.Version,
VersionUniqueIdentifier = version.GetUniqueIdentifier(versions.Select(x => x.Version)),
IssueType = issueType,
Issue = issue,
Environment = GetSession(issue.SessionId).Environment,
});
}
else
{
if (!string.IsNullOrEmpty(issueType.ExceptionTypeName))
{
if (issueType.ExceptionTypeName.Contains(searchText))
{
searchResultRows.Add(new SearchResultRowModel()
{
InitiativeName = initiative.Name,
InitiativeUniqueIdentifier = initiativeUniqueIdentifier,
ApplicationName = applications.Single(x => x.Id == version.ApplicationId).Name,
Version = version.Version,
VersionUniqueIdentifier = version.GetUniqueIdentifier(versions.Select(x => x.Version)),
IssueType = issueType,
Issue = issue,
Environment = GetSession(issue.SessionId).Environment,
});
}
}
}
}
}
}
}
}
var allEnvironments = _initiativeBusiness.GetEnvironmentColors(User.Identity.GetUserId(), _accountRepository.FindById(User.Identity.GetUserId()).UserName);
var environmentsInResult = searchResultRows.Select(x => x.Environment).Distinct();
var environments = new List <EnvironmentViewModel>();
foreach (var env in environmentsInResult)
{
if (allEnvironments.ContainsKey(env))
{
string color;
allEnvironments.TryGetValue(env, out color);
environments.Add(new EnvironmentViewModel()
{
Name = env,
Color = color,
});
}
}
model.SearchResultRows = searchResultRows;
model.Environments = environments;
return(View("SearchResults", model));
}
public RegisterIssueResponse RegisterIssue(RegisterIssueRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request", "No request object provided.");
}
if (request.Session == null)
{
throw new ArgumentException("No session object in request was provided. Need object '{ \"Session\":{...} }' in root.");
}
if (request.Session.SessionGuid == Guid.Empty)
{
throw new ArgumentException("No valid session guid provided.");
}
if (string.IsNullOrEmpty(request.Session.ClientToken))
{
throw new ArgumentException("No ClientToken provided.");
}
if (request.IssueType == null)
{
throw new ArgumentException("No IssueType object in request was provided. Need object '{ \"IssueType\":{...} }' in root.");
}
if (string.IsNullOrEmpty(request.IssueType.Message))
{
throw new ArgumentException("No message in issue type provided.");
}
if (string.IsNullOrEmpty(request.IssueType.IssueLevel))
{
throw new ArgumentException("No issue level in issue type provided.");
}
var callerIp = _membershipAgent.GetUserHostAddress();
ISession session = null;
if (request.Session.Application == null)
{
session = GetSession(request.Session.SessionGuid);
if (session == null)
{
throw new ArgumentException("Cannot find session with provided session id.").AddData("SessionGuid", request.Session.SessionGuid);
}
}
var ad = GetApplicationData(request, session);
var fingerprint = _applicationVersionBusiness.AssureApplicationFingerprint(ad.Fingerprint, ad.Version, ad.SupportToolkitNameVersion, ad.BuildTime, ad.Name, request.Session.ClientToken);
IApplication application;
try
{
application = _initiativeBusiness.RegisterApplication((ClientToken)request.Session.ClientToken, ad.Name, ad.Fingerprint);
}
catch (FingerprintException)
{
throw new ArgumentException("No value for application fingerprint provided. A globally unique identifier should be provided, perhaps a machine sid or a hash of unique data that does not change.");
}
var applicationVersion = _applicationVersionBusiness.RegisterApplicationVersionUsage(fingerprint, application.Id, ad.Version, ad.SupportToolkitNameVersion, ad.BuildTime, request.Session.Environment);
if (applicationVersion.Ignore)
{
return(new RegisterIssueResponse {
IssueTypeTicket = null, IssueInstanceTicket = null, ResponseMessage = applicationVersion.ResponseMessage, IsOfficial = applicationVersion.IsOfficial,
});
}
if (session == null)
{
if (request.Session.User.Fingerprint == null)
{
throw new ArgumentException("No user fingerprint provided.");
}
session = request.Session.ToSession(applicationVersion.Id, application.Id, DateTime.UtcNow, null, null, callerIp);
}
_sessionBusiness.RegisterSession(session);
var ud = GetUserData(request, session);
_userBusiness.RegisterUser((Fingerprint)session.UserFingerprint, ud.UserName);
var md = GetMachineData(request, session);
_machineBusiness.RegisterMachine((Fingerprint)md.Fingerprint, md.Name, md.Data);
int issueTypeTicket;
int issueTicket;
string issueTypeResponseMessage;
var mutex = new Mutex(false, application.Id.ToString());
try
{
mutex.WaitOne();
var applicationVersions = _applicationVersionBusiness.GetApplicationVersions(application.Id).ToArray();
var issueType = applicationVersion.IssueTypes.FirstOrDefault(x => request.IssueType.AreEqual(x));
if (issueType == null)
{
var issueTypes = applicationVersions.SelectMany(x => x.IssueTypes).ToArray();
var lastIssueTypeTicket = issueTypes.Any() ? issueTypes.Max(x => x.Ticket) : 0;
issueTypeTicket = lastIssueTypeTicket + 1;
var inner = ToInnerIssueType(request.IssueType.Inner);
issueType = new Quilt4.BusinessEntities.IssueType(request.IssueType.ExceptionTypeName, request.IssueType.Message, request.IssueType.StackTrace ?? string.Empty, request.IssueType.IssueLevel.ToIssueLevel(), inner, new List <IIssue>(), issueTypeTicket, null);
applicationVersion.Add(issueType);
}
else
{
issueTypeTicket = issueType.Ticket;
}
issueTypeResponseMessage = issueType.ResponseMessage;
var issues = applicationVersions.SelectMany(x => x.IssueTypes).SelectMany(x => x.Issues).ToArray();
var lastIssueTicket = issues.Any() ? issues.Max(x => x.Ticket) : 0;
issueTicket = lastIssueTicket + 1;
var issue = new Issue(request.Id, request.ClientTime, DateTime.UtcNow, request.VisibleToUser, request.Data, request.IssueThreadGuid, request.UserHandle, request.UserInput, issueTicket, session.Id);
issueType.Add(issue);
UpdateApplicationVersion(applicationVersion);
}
finally
{
mutex.ReleaseMutex();
}
var response = new RegisterIssueResponse
{
IssueTypeTicket = application.TicketPrefix + _settingsBusiness.GetIssueTypeTicketPrefix() + issueTypeTicket,
IssueInstanceTicket = application.TicketPrefix + _settingsBusiness.GetIssueTicketPrefix() + issueTicket,
ResponseMessage = applicationVersion.ResponseMessage ?? issueTypeResponseMessage,
IsOfficial = applicationVersion.IsOfficial
};
return(response);
}
