public void ShouldThrowWhenBuildPathOutisdeCloneRoot()
{
var solutionDetails = new SolutionDetails(@"C:\projects\testconsoleapp1\");
var project = new ProjectDetails(@"C:\projects\testconsoleapp1\", @"C:\projects\testconsoleapp1\TestConsoleApp1.sln");
solutionDetails.Add(project);
var projectFile = @"C:\projects\testconsoleapp1\TestConsoleApp1\TestConsoleApp1.csproj";
project = new ProjectDetails(@"C:\projects\testconsoleapp1\", projectFile);
project.AddItems("Program.cs", @"Properties\AssemblyInfo.cs");
solutionDetails.Add(project);
var incorrectConsoleRoot = @"C:\projects\testconsoleapp2\";
var binaryLogProcessingException = Assert.Throws <BinaryLogProcessingException>(() =>
{
var parsedBinaryLog = ParseLogs("testconsoleapp1-1warning.binlog", incorrectConsoleRoot);
parsedBinaryLog.BuildMessages.ToArray().Should().BeEquivalentTo(new BuildMessage[0]);
parsedBinaryLog.SolutionDetails.Should().BeEquivalentTo(solutionDetails, options => options.IncludingNestedObjects().IncludingProperties());
});
binaryLogProcessingException.Message.Should().MatchRegex($"^Error processing log. binLogPath:\'.*?testconsoleapp1-1warning.binlog\' cloneRoot:\'{incorrectConsoleRoot.Replace("\\", "\\\\")}\'$");
binaryLogProcessingException.InnerException.Message.Should().Be($@"Project file path ""C:\projects\testconsoleapp1\TestConsoleApp1\TestConsoleApp1.csproj"" is not a subpath of ""{incorrectConsoleRoot}""");
}
public static void LoadReports(XmlDocument doc, string projectPath, ProjectDetails project)
{
var automaticTaskNode = doc.SelectNodes("/Project/Tasks/AutomaticTask");
if (automaticTaskNode != null)
{
var reportsFolderExist = ReportsFolderExists(automaticTaskNode[0].BaseURI);
if (reportsFolderExist)
{
foreach (var node in automaticTaskNode)
{
var task = (XmlNode)node;
var reportNodes = task.SelectNodes("Reports/Report");
if (reportNodes == null)
{
continue;
}
foreach (var reportNode in reportNodes)
{
var report = (XmlNode)reportNode;
if (report.Attributes != null && report.Attributes["TaskTemplateId"].Value ==
"Sdl.ProjectApi.AutomaticTasks.Analysis")
{
//always overwrite the previous path, we are only interested into last analyze
project.PathToAnalyseResult = Path.Combine(projectPath, report.Attributes["PhysicalPath"].Value);
}
}
}
}
}
}
public IEnumerable <ProjectDetails> GetProjectsDetails()
{
IList <ProjectDetails> details = new List <ProjectDetails>();
using (this.unitOfWorkProvider.CreateUnitOfWork())
{
var accountId = this.currentUserProvider.GetCurrentUser().GetAccount().Id;
IList <DomainModel.Project> projects = this.projectRepository.GetByAccountId(accountId);
foreach (var project in projects)
{
var firstPostDate = this.statisticsProvider.GetFirstPostDate(project.Id);
var lastPostDate = this.statisticsProvider.GetLastPostDate(project.Id);
var projectDetails = new ProjectDetails
{
Id = project.Id,
Title = project.Title,
Url = project.VkGroup.Url,
CreationDate = firstPostDate.HasValue ? this.dateTimeHelper.GetLocalUserDate(firstPostDate.Value) : (DateTime?)null,
LastPostDate = lastPostDate.HasValue ? this.dateTimeHelper.GetLocalUserDate(lastPostDate.Value) : (DateTime?)null,
};
details.Add(projectDetails);
}
}
return(details);
}
// Set the languages for the selected project within the languages UI list
private void AddNewLanguages(ProjectDetails selectedProject)
{
try
{
var selectedProjectToExport = _projectsDataSource?.FirstOrDefault(e => e.ShouldBeExported && e.ProjectName.Equals(selectedProject.ProjectName));
if (selectedProjectToExport?.ProjectLanguages != null)
{
foreach (var language in selectedProjectToExport.ProjectLanguages.ToList())
{
var languageDetails = _languages?.FirstOrDefault(n => n.LanguageName.Equals(language.Key));
if (languageDetails == null)
{
var newLanguage = new LanguageDetails {
LanguageName = language.Key, IsChecked = true
};
_languages?.Add(newLanguage);
}
}
}
languagesListBox.DataSource = _languages;
languagesListBox.DisplayMember = "LanguageName";
languagesListBox.ValueMember = "IsChecked";
}
catch (Exception ex)
{
Log.Logger.Error($"AddNewLanguages method: {ex.Message}\n {ex.StackTrace}");
}
}
private void UnselectProjectLanguages(ProjectDetails selectedProject)
{
try
{
if (selectedProject != null)
{
var selectedLanguagesFromProject = selectedProject.ProjectLanguages.Where(n => n.Value).Select(n => n.Key).ToList();
if (!selectedLanguagesFromProject.Any() && !selectedProject.ShouldBeExported)
{
RemoveLanguageFromProject(selectedProject);
}
else
{
foreach (var languageName in selectedLanguagesFromProject)
{
RemoveSelectedLanguage(selectedProject, languageName);
}
// if the are any projects selected clear language list
if (_projectsDataSource.Count(p => p.ShouldBeExported).Equals(0))
{
_languages.Clear();
}
}
RefreshLanguageListbox();
}
}
catch (Exception ex)
{
Log.Logger.Error($"ShouldUnselectLanguages method: {ex.Message}\n {ex.StackTrace}");
}
}
// GET: Projects/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProjectDetails projectDetails = new ProjectDetails();
string userID = User.Identity.GetUserId();
projectDetails.CurrentProjectRole = this.db.GetUserRoleForProject(id.Value, userID);
if (projectDetails.CurrentProjectRole == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden));
}
projectDetails.Project = db.Projects
.Where(p => p.ProjectID == id)
.Include(p => p.Tasks)
.Include(p => p.Roles.Select(r => r.User))
.Include(p => p.Issues)
.FirstOrDefault();
projectDetails.Tasks = new TaskIndex();
// load all assgned tasks in this project
projectDetails.Tasks.AssignedTasks = this.db.Users.Where(u => u.Id == userID)
.Include(u => u.Tasks)
.SelectMany(u => u.Tasks.Where(t => t.ParentProjectID == id.Value))
.ToList();
// insert empty user to roles for dropdowns
//projectDetails.Project.Roles.Insert(0, new ProjectRole { ProjectID = projectDetails.Project.ProjectID });
return(View(projectDetails));
}
private void PrepareProjectToExport(ProjectDetails selectedProject)
{
try
{
if (selectedProject == null)
{
return;
}
var selectedProjectIndex = _projectsDataSource.IndexOf(selectedProject);
if (selectedProjectIndex <= -1)
{
return;
}
_reportService.SetReportInformation(selectedProject);
selectedProject.ShouldBeExported = true;
SetProjectLanguages(selectedProject);
copyBtn.Enabled = projListbox.SelectedItems.Count == 1;
if (projListbox.SelectedItems.Count > 0)
{
csvBtn.Enabled = true;
}
RefreshLanguageListbox();
}
catch (Exception ex)
{
Log.Logger.Error($"PrepareProjectToExport method: {ex.Message}\n {ex.StackTrace}");
}
}
public async Task <IActionResult> ProjectDetails(int projectId)
{
int userId = int.Parse(HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
Project project = null;
if (projectId > -1)
{
// user add invalid Id in url (negative)
project = await _projectRepository.GetProject(projectId);
}
if (project == null)
{
// no project with such id
ViewBag.ProjectId = projectId;
return(View("~/Views/Shared/ProjectWithInvalidId.cshtml"));
}
var ticketsWithTheirUsers = await _ticketRepository.GetAllProjectTicketsWithUsers(projectId);
// no need to validate here as if ticketsWithTheirUsers is null won't be displayed in front end
var projectDetails = new ProjectDetails()
{
UserId = userId, Project = project, Tickets = ticketsWithTheirUsers
};
return(View(projectDetails));
}
// Remove the selected language from the languages UI list
private void RemoveSelectedLanguage(ProjectDetails selectedProject, string languageName)
{
// reset count for each language
var count = 0;
// unselect language for project in data source list
selectedProject.ProjectLanguages[languageName] = false;
var projectsToBeExported = _projectsDataSource.Where(n => n.ProjectLanguages.ContainsKey(languageName) && n.ShouldBeExported).ToList();
foreach (var project in projectsToBeExported)
{
var languageShouldBeExported = project.ProjectLanguages[languageName];
if (languageShouldBeExported)
{
count++;
}
}
// that means no other project has this language selected so we can uncheck the language from the "Select language(s) for export:" box
if (count.Equals(0))
{
var languageToBeDeleted = _languages.FirstOrDefault(l => l.LanguageName.Equals(languageName));
if (languageToBeDeleted != null)
{
_languages.Remove(languageToBeDeleted);
}
}
}
/// <summary>
/// Creates project details for given project from xml file
/// </summary>
/// <param name="projNode"></param>
/// <param name="isSingleFileProject"></param>
/// <param name="reportsFolderPath"></param>
/// <returns></returns>
public ProjectDetails CreateProjectDetails(XmlNode projNode, bool isSingleFileProject, string reportsFolderPath)
{
var projectDetails = new ProjectDetails
{
ProjectLanguages = new Dictionary <string, bool>(),
ShouldBeExported = false,
ReportsFolderPath = reportsFolderPath
};
try
{
var selectSingleNode = projNode.SelectSingleNode("ProjectInfo");
if (selectSingleNode?.Attributes != null)
{
projectDetails.ProjectName = selectSingleNode.Attributes["Name"].Value;
}
projectDetails = SetProjectFilePath(projNode, projectDetails);
var projectStatus = GetProjectStatus(projectDetails.ProjectPath);
projectDetails.Status = projectStatus;
projectDetails.IsSingleFileProject = isSingleFileProject;
ConfigureProjectLanguages(projectDetails);
}
catch (Exception ex)
{
_logger.Error($"CreateProjectDetails method: {ex.Message}\n {ex.StackTrace}");
}
return(projectDetails);
}
public async Task <IActionResult> CreateProject(CreateProjectViewModel model)
{
var team = _context.Teams.SingleOrDefault(t => t.Name == model.Team.Name);
Project project = new Project
{
Title = model.Title,
Description = model.Description,
Team = team
};
//save to database
_context.Add(project);
await _context.SaveChangesAsync();
int Id = project.Id;
ProjectDetails details = new ProjectDetails()
{
Id = project.Id,
Title = project.Title,
Description = project.Description,
Tasks = project.Tasks
};
//go to details view
return(View("DetailsProjectView", details));
}
// Set the project file path
private ProjectDetails SetProjectFilePath(XmlNode projectNode, ProjectDetails projectDetails)
{
try
{
if (projectNode.Attributes == null)
{
return(projectDetails);
}
var projectFilePath = projectNode.Attributes["ProjectFilePath"]?.Value;
if (!string.IsNullOrEmpty(projectFilePath))
{
if (Path.IsPathRooted(projectFilePath))
{
projectDetails.ProjectPath = projectFilePath; //location outside standard project place
}
else
{
var projectXmlPath = Path.GetDirectoryName(ProjectsXmlPath);
if (!string.IsNullOrEmpty(projectXmlPath))
{
projectDetails.ProjectPath = Path.Combine(projectXmlPath, projectFilePath);
}
}
}
}
catch (Exception ex)
{
_logger.Error($"SetProjectFilePath method: {ex.Message}\n {ex.StackTrace}");
}
return(projectDetails);
}
public ProjectDetails GetExternalProjectDetails(string path, string reportFolderPath)
{
try
{
var fileBasedProject = new FileBasedProject(path);
var projectInfo = fileBasedProject.GetProjectInfo();
var projectDetails = new ProjectDetails
{
ProjectName = projectInfo?.Name,
ProjectPath = projectInfo?.Uri.LocalPath,
Status = GetInternalProjectStatus(fileBasedProject),
ProjectLanguages = new Dictionary <string, bool>(),
ShouldBeExported = true,
ReportsFolderPath = reportFolderPath
};
foreach (var language in projectInfo?.TargetLanguages)
{
projectDetails.ProjectLanguages.Add(language.DisplayName, true);
}
ProjectController?.Close(fileBasedProject);
return(projectDetails);
}
catch (Exception ex)
{
_logger.Error($"GetExternalProjectDetails method: {ex.Message}\n {ex.StackTrace}");
}
return(new ProjectDetails());
}
public void SetAllProjectDetails(List <ProjectDetails> allProjectDetails, ProjectDetails projectDetails)
{
if (!allProjectDetails.Any(p => p.ProjectName.Equals(projectDetails.ProjectName)))
{
allProjectDetails.Add(projectDetails);
}
}
public void NoPackageResultsTest()
{
var sourceFileToInvocations = new Dictionary <string, List <CodeEntityDetails> >
{
{
"file1", new List <CodeEntityDetails>
{
_codeEntityDetails
}
}
};
var project = new ProjectDetails
{
PackageReferences = new List <PackageVersionPair>
{
new PackageVersionPair {
PackageId = "namespace",
Version = "11.2"
}
}
};
var result = InvocationExpressionModelToInvocations.AnalyzeResults(
sourceFileToInvocations, new Dictionary <PackageVersionPair, Task <PackageDetails> >(), recommendationResults);
Assert.AreEqual(1, result.First().ApiAnalysisResults.Count);
Assert.AreEqual("11.0.1", result.First().ApiAnalysisResults.First().CodeEntityDetails.Package.Version);
Assert.AreEqual(Compatibility.UNKNOWN, result.First().ApiAnalysisResults.First().CompatibilityResults.GetValueOrDefault(ApiCompatiblity.DEFAULT_TARGET).Compatibility);
Assert.IsNull(result[0].ApiAnalysisResults[0].Recommendations.RecommendedActions.First().Description);;
}
private void SetProjectLanguages(ProjectDetails selectedProject)
{
// if an project has only one language select that language
if (selectedProject?.ProjectLanguages != null && selectedProject.ProjectLanguages.Count.Equals(1))
{
var languageName = selectedProject.ProjectLanguages.FirstOrDefault().Key;
var languageToBeSelected = _languages.FirstOrDefault(n => n.LanguageName.Equals(languageName));
if (languageToBeSelected != null)
{
languageToBeSelected.IsChecked = true;
}
else
{
var newLanguage = new LanguageDetails
{
LanguageName = languageName,
IsChecked = true
};
_languages.Add(newLanguage);
}
selectedProject.ProjectLanguages[languageName] = true;
}
var languagesAlreadySelectedForExport = _languages.Where(l => l.IsChecked).ToList();
foreach (var language in languagesAlreadySelectedForExport)
{
if (selectedProject?.ProjectLanguages != null && selectedProject.ProjectLanguages.ContainsKey(language.LanguageName))
{
selectedProject.ProjectLanguages[language.LanguageName] = true;
}
}
AddNewLanguages(selectedProject);
}
//==============================================================//
public ResponseResult GetProjectDetailsById(int pid)
{
using (var db = new PRMDataContext())
{
String query = "execute sec.GetProjectDetailsById @1";
var cmd = db.Database.Connection.CreateCommand();
cmd.CommandText = query;
cmd.Parameters.Add(new SqlParameter {
ParameterName = "@1", Value = pid
});
db.Database.Connection.Open();
var reader = cmd.ExecuteReader();
// Read User from the first Result set
var MemberList = ((IObjectContextAdapter)db)
.ObjectContext
.Translate <User>(reader).ToList();
reader.NextResult();
//Read Project From 2nd Result set
var project = ((IObjectContextAdapter)db)
.ObjectContext
.Translate <ProjectDTO>(reader).FirstOrDefault();
db.Database.Connection.Close();
var projDetails = new ProjectDetails();
projDetails.Project = project;
projDetails.Members = MemberList;
return(ResponseResult.GetSuccessObject(projDetails));
//return projDetails;
}
}
public void ShouldTestConsoleApp1Error()
{
var cloneRoot = @"C:\projects\testconsoleapp1\";
var solutionDetails = new SolutionDetails(cloneRoot);
var projectFile = @"C:\projects\testconsoleapp1\TestConsoleApp1\TestConsoleApp1.csproj";
var project = new ProjectDetails(cloneRoot, projectFile);
project.AddItems("Program.cs", @"Properties\AssemblyInfo.cs");
solutionDetails.Add(project);
var parsedBinaryLog = ParseLogs("testconsoleapp1-1error.binlog", cloneRoot);
parsedBinaryLog.BuildMessages.ToArray().Should().BeEquivalentTo(new[]
{
new BuildMessage(BuildMessageLevel.Error, projectFile, "Program.cs", 13, 13, "; expected", "CS1002"),
});
parsedBinaryLog.SolutionDetails.Should().BeEquivalentTo(solutionDetails,
options => options.IncludingNestedObjects().IncludingProperties());
parsedBinaryLog.SolutionDetails.Keys.ToArray().Should().BeEquivalentTo(
cloneRoot + @"TestConsoleApp1\TestConsoleApp1.csproj");
parsedBinaryLog.BuildMessages.Any(message => Path.IsPathRooted(message.File)).Should().BeFalse();
}
// set the paths for the language analysis reports
private void SetLanguageAnalysisReportPaths(ProjectInfo projectInfo, ProjectDetails projectDetails, XmlNode langDirNode, string reportPath)
{
try
{
if (projectDetails != null && projectDetails.LanguageAnalysisReportPaths == null)
{
projectDetails.LanguageAnalysisReportPaths = new Dictionary <string, string>();
}
if (langDirNode?.Attributes == null)
{
return;
}
var targetLangCode = langDirNode?.Attributes["TargetLanguageCode"].Value;
var language = projectInfo?.TargetLanguages?.FirstOrDefault(n => n.IsoAbbreviation.Equals(targetLangCode));
if (language == null)
{
return;
}
if (projectDetails != null && !projectDetails.LanguageAnalysisReportPaths.ContainsKey(language.DisplayName))
{
projectDetails.LanguageAnalysisReportPaths.Add(language.DisplayName, reportPath);
}
}
catch (Exception ex)
{
Log.Logger.Error($"SetLanguageAnalysisReportPaths method: {ex.Message}\n {ex.StackTrace}");
}
}
private ProjectViewModel ToProjectViewModel(ProjectDetails project)
{
var tasks = _taskRepository.GetAllRecord().Where(p => p.ProjectId == project.ProjectId);
var taskCount = tasks.Count();
var isAllTasksCompleted = tasks
.All(s => !string.IsNullOrEmpty(s.Status) &&
string.Equals("Yes", s.Status, StringComparison.InvariantCultureIgnoreCase));
var manager = _userRepository.GetAllRecord().FirstOrDefault(p => p.ProjectId == project.ProjectId);
var managerName = "";
var managerId = 0;
if (manager != null)
{
managerName = string.Format("{0} {1}", manager.FirstName, manager.LastName);
managerId = manager.UserId;
}
return(new ProjectViewModel
{
ProjectId = project.ProjectId,
ProjectName = project.Title,
StartDate = project.StartDate,
EndDate = project.EndDate,
Priority = project.Priority,
Manager = managerName,
UserId = managerId,
Completed = isAllTasksCompleted ? "Yes" : "No",
NumberOfTasks = taskCount
});
}
private void UpdateProjectsDropdown()
{
projectsList.Items.Clear();
foreach (ProjectDetails p in ProjectsManager.projects.Values)
{
projectsList.Items.Add(p.name);
}
if (projectsList.Items.Count > 0)
{
projectsList.IsEnabled = true;
CurrentProject = ProjectsManager.projects[projectsList.Items[0].ToString()];
}
else
{
OutputManager.WriteLine("No projects in current solution.");
ComboBoxItem none = new ComboBoxItem();
TextBlock tb = new TextBlock();
tb.Text = "No Projects Loaded";
tb.FontStyle = FontStyles.Italic;
tb.Foreground = new SolidColorBrush(Colors.DarkSlateGray);
none.Content = tb;
projectsList.Items.Add(none);
projectsList.IsEnabled = false;
Settingstabs.SelectedItem = tabNoProject;
CurrentProject = null;
}
projectsList.SelectedItem = projectsList.Items[0];
}
private void ProjectsComboChanged(object sender, SelectionChangedEventArgs e)
{
if (ProjectsManager.projects.Count < 1 || projectsList.SelectedValue == null)
{
return;
}
CurrentProject = ProjectsManager.projects[projectsList.SelectedValue.ToString()];
if (CurrentProject.HasLocalizerSettings)
{
OutputManager.WriteLine("Selected project has Localizer settings. Setting up the databind...");
//load the text boxes
this.DataContext = this.CurrentProject;
//tagProjectPortion.Text = CurrentProject.localizerSettings.ProjectSettings.TagProjectPortion;
Settingstabs.SelectedItem = tabSettings;
MultiFile.IsEnabled = CurrentProject.LocalizerSettings.ProjectSettings.UseMultiCfgFiles;
BaseFile.IsEnabled = !CurrentProject.LocalizerSettings.ProjectSettings.UseMultiCfgFiles;
BaseFileSelector.IsEnabled = !CurrentProject.LocalizerSettings.ProjectSettings.UseMultiCfgFiles;
UpdateSampleText(true);
}
else
{
OutputManager.WriteLine("Selected project has no Localizer settings.");
Settingstabs.SelectedItem = tabNoSettings;
}
}
public override ProjectDetails GetModelByRow(DataRow row)
{
try
{
ProjectDetails ProjectDetails = new ProjectDetails()
{
CementContent = row["CementContent"].ToString(),
DetailsId = row["DetailsId"].ToString(),
DetailsTilte = row["DetailsTilte"].ToString(),
DisplayOrder = int.Parse(row["DisplayOrder"].ToString()),
// Instar = int.Parse(row["Instar"].ToString()),
Intensity = row["Intensity"].ToString(),
Mileage = row["Mileage"].ToString(),
MixDesign = row["MixDesign"].ToString(),
ProjectId = row["ProjectId"].ToString(),
// SamplingDate = row["SamplingDate"].ToString(),
SerialNumber = row["SerialNumber"].ToString(),
DetailState = int.Parse(row["DetailState"].ToString())
};
// ProjectDetails.DeviceDataList = ListSupport.ToList<Models.DeviceData>(new DeviceDataDal().GetData(" ProjectDetailId=@ProjectDetailId ", new System.Data.OleDb.OleDbParameter("@ProjectDetailId", ProjectDetails.DetailsId)));
return(ProjectDetails);
}
catch {
return(null);
}
}
private void SetLanguagesForProject(ProjectDetails project, Dictionary <string, LanguageDirection> languages)
{
foreach (var language in languages)
{
project.LanguagesForPoject.Add(language.Value.TargetLang.EnglishName, false);
}
}
private async Task ExtractNugetInfo(ProjectDetails project, DotNetProject projectInfo)
{
var nugets = await ReadNuget(project.AbsolutePath, projectInfo);
project.Nugets.AddRange(nugets);
foreach (var nuget in project.Nugets)
{
var nugetMap = new NugetProjectMap
{
Nuget = nuget,
Project = project
};
_nugetCache.AddOrUpdate(nuget.Name, new Dictionary <string, NugetProjectMap> {
[nugetMap.Project.AbsolutePath] = nugetMap
}, (pKey, nugets) =>
{
if (!nugets.ContainsKey(nugetMap.Project.AbsolutePath))
{
nugets.Add(nugetMap.Project.AbsolutePath, nugetMap);
}
return(nugets);
});
}
}
public IHttpActionResult UpdateProject([FromBody] ProjectDetails projectToUpdate)
{
ProjectBusiness tb = new ProjectBusiness();
tb.UpdateProject(tb.GetProjectFromDetails(projectToUpdate));
return(Ok(projectToUpdate));
}
// POST: Invoices/Delete/5
//Eliminar factura
public void DeleteConfirmed(int id)
{
Invoice invoice = db.Invoice.Find(id);
//Actualizando el Detalle
ProjectDetails pd = db.ProjectDetails.Find(invoice.InvoiceProjectDetails.First().ProjectDetailsSpecialist.projectDetailsId);
pd.totalInvoiced = pd.totalInvoiced - invoice.amount;
pd.toInvoice = pd.totalContracted - pd.totalInvoiced;
//Actualizar Proyecto
pd.ProjSup.Project.totalnvoiced = decimal.Parse((pd.totalInvoiced - invoice.amount).ToString());
pd.ProjSup.Project.toInvoiced = decimal.Parse((pd.totalContracted - pd.totalInvoiced).ToString());
//Actualizar Estado del SUplemento
Supplement s = pd.ProjSup.Supplement;
double facturado = s.ProjSup.Sum(z => z.ProjectDetails.Sum(ss => ss.totalInvoiced));
if (Math.Abs(facturado - decimal.ToDouble(s.amount)) < 0.1)
{
foreach (var state in s.StateCSupplement)
{
state.state = false;
}
StateC terminado = db.StateC.Find(10);
StateCSupplement stateCSupplement = new StateCSupplement
{
stateCId = terminado.stateCId,
Supplement = s,
date = DateTime.Now,
description = "Maximo de facturacion alcanzada",
state = true
};
db.StateCSupplement.Add(stateCSupplement);
}
else
{
if (s.StateCSupplement.First(a => a.state).stateCId == 10)
{
foreach (var state in s.StateCSupplement)
{
state.state = false;
}
StateC iniciado = db.StateC.Find(5);
StateCSupplement stateCSupplement = new StateCSupplement
{
stateCId = iniciado.stateCId,
Supplement = s,
date = DateTime.Now,
description = "Estado cambiado dinamicamente x Ediacion de Facturas",
state = true
};
db.StateCSupplement.Add(stateCSupplement);
}
}
db.InvoiceProjectDetails.RemoveRange(invoice.InvoiceProjectDetails);
db.InvoiceStateSet.RemoveRange(invoice.InvoiceStateSet);
db.Invoice.Remove(invoice);
db.SaveChanges();
}
public async IAsyncEnumerable <Reference> FindReferenceInSolutions(ProjectDetails project, ISymbol searchElement, IProgress <string> progress)
{
//TODO what if project that is using project form argument is used in many solutions
var resultCache = new List <Reference>();
var projects = _projectUsedByCache[project.AbsolutePath];
int current = 0;
var solutions = projects.Values
.SelectMany(s => _projectToSolutionMap[s.AbsolutePath])
.Distinct();
foreach (var solution in solutions)
{
current++;
progress.Report($"Searching for {searchElement.Name} in {solution} [{current}/{projects.Count}]");
var solutionWorkspace = await OpenSolution(solution);
await foreach (var result in FindSymbol(searchElement, solutionWorkspace, project))
{
if (resultCache.Contains(result))
{
continue;
}
resultCache.Add(result);
yield return(result);
}
}
}
public ActionResult <ProjectDetails> PostProjectDetails(ProjectDetails projectDetails)
{
user = _context.Users.FirstOrDefault(c => c.Id == User.FindFirst(ClaimTypes.NameIdentifier).Value);
//var getProjectDetails = _context.ProjectDetails.Include(c => c.StartDate).FirstOrDefault(c => c.ProjectId == projectDetails.ProjectId);
if (projectDetails.CompletedDate.Value != DateTime.MinValue || projectDetails.StartDate != DateTime.MinValue)
{
projectDetails.HoursWorked = Math.Round(projectDetails.CompletedDate.Value.Subtract(projectDetails.StartDate).TotalHours, 2);
}
projectDetails.CreatedDate = DateTime.Now;
projectDetails.CreatedBy = user.Email;
_context.ProjectDetails.Add(projectDetails);
_context.SaveChanges();
if (projectDetails.IsCompleted)
{
var getProject = _context.Projects.Include(c => c.ProjectDetails).FirstOrDefault(c => c.Id == projectDetails.ProjectId);
getProject.IsCompleted = true;
getProject.HoursWorked = Math.Round(getProject.ProjectDetails.Sum(c => c.HoursWorked), 2);
_context.Projects.Update(getProject);
_context.SaveChanges();
}
return(CreatedAtAction("GetProjectDetails", new { id = projectDetails.Id }, projectDetails));
}
public WorkorderGeneration(int jobID)
{
WoID = 0;
_jobID = jobID;
_cp = new ProjectCompany(_jobID);
_p = new ProjectDetails(_jobID);
}
public ChangeTracker(LoggerContext logger, ProjectDetails projectDetails)
{
weaverFinder = new WeaverFinder(logger, projectDetails);
foreach (var file in weaverFinder.FindWeaverConfigs().Concat(weaverFinder.FindWeavers()))
{
weaverLastChangeCache.Add(file, File.GetLastWriteTimeUtc(file));
}
}
public AppDomainWorker(LoggerContext logger, ProjectDetails config, string tempDirectory)
{
this.config = config;
this.logger = logger;
this.tempDirectory = tempDirectory;
}
protected void BtnCreate_Click(object sender, EventArgs e)
{
Repository db = new Repository();
ProjectDetails prjtdetails = new ProjectDetails();
}
