//GuiUpdateHelper _updater;
public TreeViewAdvModel(ProjectVM treeVM, TreeViewAdv treeView)
{
_tree = treeVM;
_treeView = treeView;
_tree.ChildrenInvalidated += row => AutoRefresh(row, true);
_tree.RowInvalidated += row => AutoRefresh(row, false);
}
public int InsertOrUpdateProject(ProjectVM _obj)
{
int result = 0;
DataTable tvp = new DataTable();
tvp.Columns.Add(new DataColumn("id", typeof(int)));
foreach (var id in _obj.careTakerIds ?? new List <int>())
{
tvp.Rows.Add(id);
}
using (SqlConnection con = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand("isp_Project", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@projectId", _obj.projectId);
cmd.Parameters.AddWithValue("@projectName", _obj.projectName);
cmd.Parameters.AddWithValue("@projectType", _obj.projectType);
cmd.Parameters.AddWithValue("@projectAddress", _obj.projectAddress);
cmd.Parameters.AddWithValue("@projectDescription", _obj.projectDescription);
cmd.Parameters.AddWithValue("@createdBy", _obj.createdBy);
cmd.Parameters.AddWithValue("@List", tvp);
result = 1;
con.Open();
cmd.ExecuteNonQuery();
con.Close();
}
return(result);
}
public void Matches_OrStepWithTwoPropertySteps_MatchesIfOneOfThePropertiesMatches()
{
var selectedProjectStep = CreatePropertyStep((EmployeeVMDescriptor x) => x.SelectedProject);
var nameStep = CreatePropertyStep((EmployeeVMDescriptor x) => x.Name);
var orStep = new OrStep(selectedProjectStep, nameStep);
var definition = PathDefinition
.Empty
.Append(orStep);
var projectVM = new ProjectVM();
var rootVM = new EmployeeVM();
rootVM.SetValue(x => x.SelectedProject, projectVM);
var namePath = Path
.Empty
.Append(rootVM)
.Append(EmployeeVM.ClassDescriptor.Name);
var match = definition.Matches(namePath);
Assert.IsTrue(match.Success);
var selectedProjectPath = Path
.Empty
.Append(rootVM)
.Append(EmployeeVM.ClassDescriptor.SelectedProject);
match = definition.Matches(namePath);
Assert.IsTrue(match.Success);
}
public void Matches_ChildViewModelPlusOptionalStepWithAnyStepsStep_MacthesPropertyOfChildChildViewModel()
{
var definition = PathDefinition
.Empty
.Append((EmployeeVMDescriptor x) => x.SelectedProject)
.Append(new OptionalStep(new AnyStepsStep <ProjectVMDescriptor>()));
var customerVM = new CustomerVM();
var projectVM = new ProjectVM();
projectVM.SetValue(x => x.SelectedCustomer, customerVM);
var rootVM = new EmployeeVM();
rootVM.SetValue(x => x.SelectedProject, projectVM);
var path = Path
.Empty
.Append(rootVM)
.Append(rootVM.GetValue(x => x.SelectedProject))
.Append(projectVM.GetValue(x => x.SelectedCustomer))
.Append(CustomerVM.ClassDescriptor.Name);
var match = definition.Matches(path);
Assert.IsTrue(match.Success);
}
public ActionResult Edit(ProjectVM poViewModel)
{
ViewBag.AC_MENU_ID = valMENU.TSK_PROJECT_EDIT;
this.oVAL = new Project_Validation(poViewModel, this.oDS);
this.oVAL.Validate_Edit();
//Add Error if exists
for (int i = 0; i < this.oVAL.aValidationMSG.Count; i++)
{
ModelState.AddModelError(this.oVAL.aValidationMSG[i].VAL_ERRID, this.oVAL.aValidationMSG[i].VAL_ERRMSG);
} //End for (int i = 0; i < this.oVAL.aValidationMSG.Count; i++)
if (ModelState.IsValid)
{
this.oCRUD.Update(poViewModel);
this.oCRUD.Commit();
if (this.oCRUD.isERR)
{
TempData["ERRMSG"] = this.oCRUD.ERRMSG;
return(RedirectToAction("ErrorSYS", "Error"));
} //End if (!this.oCRUD.isERR) {
TempData["CRUDSavedOrDelete"] = valFLAG.FLAG_TRUE;
return(RedirectToAction("Details", new { id = this.oCRUD.ID }));
}
return(View(poViewModel));
}
private void OpenSharedProjectBtn_Click(object sender, RoutedEventArgs e)
{
Button b = sender as Button;
if (b == null)
{
return;
}
StackPanel s = b.Content as StackPanel;
if (s == null)
{
return;
}
ProjectVM pvm = s.DataContext as ProjectVM;
if (pvm == null)
{
return;
}
SharedProjectPage mpp = new SharedProjectPage(pvm);
mpp.Show();
this.Close();
}
public JsonResult InsertOrUpdate(ProjectVM projectVM)
{
var client = new HttpClient
{
BaseAddress = new Uri("https://localhost:44320/api/")
};
client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString(("JWToken")));
projectVM.Manager_Id = HttpContext.Session.GetString("Id");
var myContent = JsonConvert.SerializeObject(projectVM);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
if (projectVM.Id.Equals(0))
{
var result = client.PostAsync("Project/Insert", byteContent).Result;
return(Json(result));
}
else
{
var result = client.PutAsync("Project/" + projectVM.Id, byteContent).Result;
return(Json(result));
}
}
public JsonResult InsertOrUpdateProject(ProjectVM _obj)
{
try
{
_obj.createdBy = Convert.ToInt32(Session["userId"]);
int result = _da.InsertOrUpdateProject(_obj);
if (_obj.projectId == 0)
{
return(Json(new { success = true, message = "Data Saved" }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { success = true, message = "Data Updated" }, JsonRequestBehavior.AllowGet));
}
}
catch (Exception ex)
{
if (ex.Message.Contains("Violation of UNIQUE KEY"))
{
return(Json(new { success = false, message = "Project with this name already Exists!!" }, JsonRequestBehavior.AllowGet));
}
if (ex.Message.Contains(@"Violation of PRIMARY KEY constraint 'PK_tblProjectCareTaker'"))
{
return(Json(new { success = false, message = "Duplicate CareTaker cannot be added!" }, JsonRequestBehavior.AllowGet));
}
return(Json(new { success = false, message = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
public void Repopulate_SourceItemFound_AddsVM()
{
Assert.Inconclusive("Refactor");
var context = new ContextTestHelper(new EmployeeVM());
var projectSource = new Project();
var projectVM = new ProjectVM(projectSource);
var additionalProjectVM = new ProjectVM(new Project());
var lookupCollection = new[] { projectVM, additionalProjectVM };
var sourceCollection = new[] { projectSource };
var behavior = CreateBehavior(lookupCollection, sourceCollection);
var collection = VMCollectionStub
.Of <ProjectVM>()
.WithOwner(context.VM)
.Build();
throw new NotImplementedException();
//behavior.GetValue(
//behavior.Repopulate(context.Context, collection);
//CollectionAssert.AreEquivalent(
// new[] { projectVM },
// collection
//);
}
void Save(ProjectVM project)
{
if (App.Current.Config.AutoSave)
{
App.Current.DatabaseManager.ActiveDB.Store(project.Model);
}
}
public ActionResult <ProjectVM> GetEmployeeAssignedProjects(int id)
{
var listOfProjmgts = _context.ProjectManagements.Where(p => p.EmployeeId == id).ToList();
List <ProjectVM> ListprojectVM = new List <ProjectVM>();
if (listOfProjmgts != null)
{
foreach (var item in listOfProjmgts)
{
if (_context.Projects.Find(item.ProjectId).StatusTypeId == (int)EStatusType.Active)
{
ProjectVM project = new ProjectVM()
{
Id = item.ProjectId,
ProjectName = _context.Projects.Find(item.ProjectId).ProjectName
};
ListprojectVM.Add(project);
}
}
return(Ok(ListprojectVM));
}
return(Ok(new RespStatus {
Status = "Success", Message = "No Projects Assigned to Employee"
}));
}
public ActionResult Create(ProjectVM ProjectVM, HttpPostedFileBase Image)
{
Project ProjectDomain = new Project()
{
Description = ProjectVM.Description,
Category = (Category)ProjectVM.Category,
Image = Image.FileName,
Name = ProjectVM.Name,
TeamId = ProjectVM.TeamId
};
MyProjectService.Add(ProjectDomain);
MyProjectService.Commit();
//ajout de l'image dans un dossier Upload
var path = Path.Combine(Server.MapPath("~/Content/Upload/"), Image.FileName);
Image.SaveAs(path);
return(RedirectToAction("Index"));
//MailMessage mail = new MailMessage("*****@*****.**", "*****@*****.**", "Projet pret", "votre projet est maitenant assigné a un groupe d'ing");
//// MailMessage mail = new MailMessage();
//mail.IsBodyHtml = true;
//SmtpClient smtpClient = new SmtpClient("Smtp.gmail.com", 587);
//smtpClient.EnableSsl = true;
//smtpClient.Credentials = new System.Net.NetworkCredential("*****@*****.**", "dina123");
//smtpClient.Send(mail);
}
public ActionResult Edit([Bind(Prefix = "Project")] Project project)
{
Project dbProject = UOW.Projects.GetById(project.Id);
if (dbProject != null)
{
dbProject.Name = project.Name;
dbProject.Description = project.Description;
dbProject.Status = project.Status;
dbProject.StartDate = project.StartDate;
dbProject.EstimatedCompletionDate = project.EstimatedCompletionDate;
dbProject.CompletionDate = project.CompletionDate;
dbProject.AccountId = project.AccountId;
UOW.Commit();
project = dbProject;
}
ProjectVM vm = new ProjectVM
{
Project = project,
Accounts = UOW.Accounts.GetAll()
};
return(View(vm));
}
public ActionResult SaveReportData(int?id)
{
// SeniorProject seniorProject = db.SeniorProject.OrderByDescending(o => o.SPtId).FirstOrDefault();
SeniorProject seniorProject = new SeniorProject();
seniorProject = db.SeniorProjects.Find(id);
if (seniorProject == null)
{
return(HttpNotFound());
}
ProjectVM project = new ProjectVM();
project = GetStuFromPDF(seniorProject.SPtId);
project.SPName = seniorProject.SPName;
project.SPtId = seniorProject.SPtId;
/*List<Student> students = new List<Student>();
* students=obj.StudentsAndID;
* /* Supervisors sup = new Supervisors();
* sup=obj.Sup;
* seniorProject.SPAbstract = obj.Project.SPAbstract;
* var TwoModel = new ProjectAndStudentModels { project = seniorProject, StudentsAndID = students, supervisors = sup };
*/
return(View(project));
}
public ActionResult Create([Bind(Prefix = "Project")] Project project)
{
if (ModelState.IsValid)
{
Project newProject = new Project();
newProject.Id = Guid.NewGuid();
newProject.Name = project.Name;
newProject.Description = project.Description;
newProject.Status = project.Status;
newProject.StartDate = project.StartDate;
newProject.EstimatedCompletionDate = project.EstimatedCompletionDate;
newProject.CompletionDate = project.CompletionDate;
newProject.CreatedDate = DateTime.Now;
newProject.AccountId = project.AccountId;
UOW.Projects.Add(newProject);
UOW.Commit();
project = newProject;
}
ProjectVM vm = new ProjectVM
{
Project = project,
Accounts = UOW.Accounts.GetAll()
};
return(View("Edit", vm));
}
public IHttpActionResult Get(int id)
{
string userId = User.Identity.GetUserId();
ProjectVM project = _adapter.GetProject(id);
return(Ok(project));
}
public static void OpenProject(ProjectVM project, CaptureSettings props = null)
{
Log.Information($"Open project {project.ProjectType}");
dynamic settings = new ExpandoObject();
settings.Project = project;
settings.CaptureSettings = props;
if (project.ProjectType == ProjectType.FakeCaptureProject)
{
App.Current.StateController.MoveTo(FakeLiveProjectAnalysisState.NAME, settings, true);
}
else if (project.Model.IsFakeCapture)
{
App.Current.StateController.MoveTo(NewProjectState.NAME, project);
}
else if (project.ProjectType == ProjectType.FileProject || project.ProjectType == ProjectType.EditProject)
{
App.Current.StateController.MoveTo(ProjectAnalysisState.NAME, settings, true);
}
else
{
App.Current.StateController.MoveTo(LiveProjectAnalysisState.NAME, settings, true);
}
App.Current.EventsBroker.Publish(new OpenedProjectEvent {
Project = project.Model
});
}
public ActionResult Index(int?teamid, string teamname = "")
{
try
{
if (teamid.HasValue)
{
//User switched team from the header menu
UpdateTeam(teamid.Value);
repo.SaveDefaultTeam(UserID, teamid.Value);
}
var vm = new DashBoardVM {
TeamID = TeamID
};
var projectList = repo.GetProjects(TeamID).Where(s => s.TeamID == TeamID).ToList();
foreach (var project in projectList)
{
var projectVM = new ProjectVM {
ID = project.ID, Name = project.Name, Description = project.Description
};
projectVM.IsProjectOwner = (project.CreatedByID == UserID);
vm.Projects.Add(projectVM);
}
vm.RecentIssues = GetRecentIssues();
vm.IssuesAssignedToMe = GetIssuesAssignedToMe();
return(View(vm));
}
catch (Exception ex)
{
log.Error(ex);
return(View("Error"));
}
}
public void DependencyOnTargetPropertiesOfDescendantCollection_RefreshesAllPropertiesOfAllViewModelsInCollection()
{
var refreshMock = new RefreshControllerBehaviorMock();
var projectVMDescriptor = ProjectVM.CreateDescriptor(refreshMock, true);
var employeeVM = CreateEmployeeVM(
b => b
.OnChangeOf
.Properties(x => x.Name)
.Refresh
.Descendant(x => x.Projects)
.Properties(x => x.Title, x => x.Customer),
projectVMDescriptor
);
var projectVM1 = CreateProjectVM();
var projectVM2 = CreateProjectVM();
employeeVM.Projects.Add(projectVM1);
employeeVM.Projects.Add(projectVM2);
employeeVM.Name = "TriggerChange";
var expectedRefreshedProperties = new IVMPropertyDescriptor[] {
projectVM1.Descriptor.Title,
projectVM1.Descriptor.Customer,
projectVM1.Descriptor.Title,
projectVM1.Descriptor.Customer,
};
var refreshedProperties = refreshMock.RefreshedProperties;
CollectionAssert.AreEquivalent(expectedRefreshedProperties, refreshedProperties);
}
public ActionResult updateSupervisor(ProjectVM model)
{
try
{
SeniorProject project = db.SeniorProjects.Find(model.SPtId);
project.supervisorUserId = model.supervisor.userId;
User sup = db.Users.Find(model.userId);
if (sup == null)
{
sup = new User();
sup.userId = model.supervisor.userId;
sup.userId = model.supervisor.userName;
sup.userRole = model.supervisor.userRole = 2;
using (Entities entity = new Entities())
{
entity.Users.Add(sup);
entity.SaveChanges();
}
}
db.Entry(project).State = EntityState.Modified;
db.SaveChanges();
return(new JsonResult
{
Data = "Supervisor updated successfully"
});
}
catch (Exception ex)
{
return(new JsonResult
{
Data = "an error occurred"
});
}
}
public void SetCurrentlyOpenedProject(ProjectFolderVM projectFolder, Action goBackClickHandler)
{
if (CurrentlyOpenedProject != null)
{
CurrentlyOpenedProject.OnGoBackClick -= _currentlyOpenedProject_OnGoBackClick;
}
if (projectFolder == null)
{
CurrentlyOpenedProject = null;
_goBackClickHandler = null;
}
else
{
CurrentlyOpenedProject = new ProjectVM(this, projectFolder)
{
Name = projectFolder.Name,
CollectionsVM = projectFolder.CollectionsVM,
Summary = projectFolder.Summary,
CustomerName = projectFolder.CustomerName,
CustomerEmail = projectFolder.CustomerEmail
};
CurrentlyOpenedProject.Init();
_goBackClickHandler = goBackClickHandler;
CurrentlyOpenedProject.OnGoBackClick += _currentlyOpenedProject_OnGoBackClick;
}
NotifyPropertyChanged("CurrentlyOpenedProject");
}
public Task <IViewComponentResult> InvokeAsync(long IdProject)
{
ProjectVM Project = _mapper.Map <ProjectVM>(_administrationBLLocator.ProjectBL.CRUD.GetById(IdProject));
return(Task.FromResult <IViewComponentResult>(View(Project ?? new ProjectVM())));
}
public ActionResult CreateProject(ProjectVM project)
{
var mediator = new ProjectMediator();
var uMediator = new UserMediator();
if (string.IsNullOrWhiteSpace(project.DueDate))
{
ViewBag.ControllerAction = "CreateProject";
ViewBag.PageTitle = "Create Project";
ModelState.AddModelError("ErrorMessage", "Please select a Due Date");
project.CompanyEmployees = uMediator.GetUsersByCompanyId(project.CompanyId);
return(View("~/Views/Project/ProjectForm.cshtml", project));
}
bool success = mediator.CreateProject(project);
if (success)
{
return(Redirect("~/project/index"));
}
else
{
ViewBag.ControllerAction = "CreateProject";
ViewBag.PageTitle = "Create Project";
ModelState.AddModelError("ErrorMessage", "Unable to create project. Please verify input.");
project.CompanyEmployees = uMediator.GetUsersByCompanyId(project.CompanyId);
return(View("~/Views/Project/ProjectForm.cshtml", project));
}
}
private void OnRunButtonClicked(object sender, RoutedEventArgs e)
{
ProjectVM project = Class.Project;
project.PropertyChanged += OnProjectPropertyChangedWhileCompiling;
project.CompileProject();
}
public void SetUp()
{
videoPlayerVM = new VideoPlayerVM();
videoPlayerControllerMock = new Mock <IVideoPlayerController> ();
videoPlayerVM.Player = videoPlayerControllerMock.Object;
Project project = Utils.CreateProject(false);
var period = new Period();
period.Nodes.Add(new TimeNode {
Start = new Time(0),
Stop = new Time(3000)
});
project.Periods.Add(period);
projectVM = new DummyProjectVM {
Model = project
};
camSyncVM = new CameraSynchronizationVM {
VideoPlayer = videoPlayerVM, Project = projectVM
};
camSyncController = new CameraSynchronizationController();
videoPlayerControllerMock.ResetCalls();
stateControllerMock.ResetCalls();
KeyContext context = new KeyContext();
foreach (KeyAction action in camSyncController.GetDefaultKeyActions())
{
context.AddAction(action);
}
App.Current.KeyContextManager.NewKeyContexts(new List <KeyContext> {
context
});
}
public void GetDescendants_DesendantCollection_ReturnsAllViewModelsInCollection()
{
var path = PathDefinition
.Empty
.Append((EmployeeVMDescriptor x) => x.Projects);
var project1 = new ProjectVM();
var project2 = new ProjectVM();
var project3 = new ProjectVM();
var expectedViewModels = new ProjectVM[] {
project1,
project2,
project3
};
var rootVM = new EmployeeVM();
var projects = rootVM.GetValue(x => x.Projects);
projects.Add(project1);
projects.Add(project2);
projects.Add(project3);
var descenantViewModels = path.GetDescendants(rootVM);
CollectionAssert.AreEqual(expectedViewModels, descenantViewModels);
}
//GuiUpdateHelper _updater;
public TreeViewAdvModel(ProjectVM treeVM, TreeViewAdv treeView)
{
_tree = treeVM;
_treeView = treeView;
_tree.ChildrenInvalidated += row => AutoRefresh(row, true);
_tree.RowInvalidated += row => AutoRefresh(row, false);
}
public ProjectVM GetById(int id)
{
var service_result = service.GetById(id);
ProjectVM api_result = Mapper.Map <Project, ProjectVM>(service_result);
return(api_result);
}
public void Setup()
{
VM = new EmployeeVM();
var projectVM = new ProjectVM();
VM.GetValue(x => x.Projects).Add(projectVM);
VM.SetValue(x => x.SelectedProject, projectVM);
}
public ActionResult ProjectDetails(int id)
{
var model = new ProjectVM();
var mediator = new ProjectMediator();
model = mediator.GetProject(id);
return(View("~/Views/Project/ProjectDetail.cshtml", model));
}
private EmployeeVM CreateEmployeeVM(
Action <IVMDependencyBuilder <EmployeeVM, EmployeeVMDescriptor> > dependencyConfigurationAction,
ProjectVMDescriptor projectVMDescriptor = null
)
{
projectVMDescriptor = projectVMDescriptor ?? ProjectVM.CreateDescriptor(null, false);
return(new EmployeeVM(dependencyConfigurationAction, projectVMDescriptor, true, Results, new RefreshControllerBehaviorMock()));
}
public ProjectRuleView(ProjectVM proj, ProjectRuleVM rule) {
InitializeComponent();
this.rule = rule;
this.proj = proj;
DataContext = rule;
rule.PropertyChanged += OnPropertyChanged;
CheckValidity();
}
public TestingForm(ProjectVM tree)
{
_tree = tree;
InitializeComponent();
_tvAdvModel = new TreeViewAdvModel(tree, _testTreeView);
_testTreeView.Model = _tvAdvModel;
_updater = new GuiUpdateHelper(Options_PropertyChanged);
}
/// <summary>
/// Shows project to edit
/// </summary>
/// <param name="id">project to edig</param>
/// <returns>Edit-view</returns>
public ActionResult Edit(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Project project = db.Projects.Find(id);
bool isActive = false;
if (project.Active == 1)
{
isActive = true;
}
ProjectVM projectVM = new ProjectVM
{
ProjectId = project.ProjectId,
ProjectNo = project.ProjectNo,
Name = project.Name,
Detail = project.Detail,
IsActive = isActive,
UserId = project.UserId
};
if (project == null)
{
return HttpNotFound();
}
ViewBag.UserId = new SelectList(db.Users, "UserId", "Email", project.UserId);
return View(projectVM);
}
void NewProj() {
if (!PromptSave())
return;
Project = new ProjectVM(new ConfuserProject(), null);
FileName = "Unnamed.crproj";
}
public ProjectTabAdvancedView(ProjectVM project)
{
InitializeComponent();
this.project = project;
DataContext = project;
}
void OpenProj() {
if (!PromptSave())
return;
var ofd = new VistaOpenFileDialog();
ofd.Filter = "ConfuserEx Projects (*.crproj)|*.crproj|All Files (*.*)|*.*";
if ((ofd.ShowDialog(Application.Current.MainWindow) ?? false) && ofd.FileName != null) {
string fileName = ofd.FileName;
try {
var xmlDoc = new XmlDocument();
xmlDoc.Load(fileName);
var proj = new ConfuserProject();
proj.Load(xmlDoc);
Project = new ProjectVM(proj, fileName);
FileName = fileName;
}
catch {
MessageBox.Show("Invalid project!", "ConfuserEx", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
