public OperatorActivitiesVM(OperatorVM opr, AccessType access) : base(access)
        {
            UnitOfWork = new SoheilEdmContext();
            CurrentOperator = opr;
            OperatorDataService = new OperatorDataService(UnitOfWork);
            OperatorDataService.ActivityAdded += OnActivityAdded;
            OperatorDataService.ActivityRemoved += OnActivityRemoved;
            ActivityDataService = new ActivityDataService(UnitOfWork);
            ActivityOperatorDataService = new ActivitySkillDataService(UnitOfWork);
            ActivityGroupDataService = new ActivityGroupDataService(UnitOfWork);

            var selectedVms = new ObservableCollection<ActivityOperatorVM>();
            foreach (var generalActivitySkill in OperatorDataService.GetActivities(opr.Id))
            {
                selectedVms.Add(new ActivityOperatorVM(generalActivitySkill, Access, ActivityOperatorDataService, RelationDirection.Reverse));
            }
            SelectedItems = new ListCollectionView(selectedVms);

            var allVms = new ObservableCollection<ActivityVM>();
            foreach (var activity in ActivityDataService.GetActives()
				.Where(activity => !selectedVms.Any(activityOperator => activityOperator.ActivityId == activity.Id)))
            {
                allVms.Add(new ActivityVM(activity, Access, ActivityDataService, ActivityGroupDataService));
            }
            AllItems = new ListCollectionView(allVms);

            IncludeCommand = new Command(Include, CanInclude);
            ExcludeCommand = new Command(Exclude, CanExclude);
            
        }
        public ActivityOperatorsVM(ActivityVM activity, AccessType access)
            : base(access)
        {
            UnitOfWork = new SoheilEdmContext();
            CurrentActivity = activity;
            ActivityDataService = new ActivityDataService(UnitOfWork);
            ActivityDataService.OperatorAdded += OnOperatorAdded;
            ActivityDataService.OperatorRemoved += OnOperatorRemoved;
            OperatorDataService = new OperatorDataService(UnitOfWork);
            ActivityOperatorDataService = new ActivitySkillDataService(UnitOfWork);

            var selectedVms = new ObservableCollection<ActivityOperatorVM>();
            foreach (var activityOperator in ActivityDataService.GetOperators(activity.Id))
            {
                selectedVms.Add(new ActivityOperatorVM(activityOperator, Access, ActivityOperatorDataService, RelationDirection.Straight));
            }
            SelectedItems = new ListCollectionView(selectedVms);

            var allVms = new ObservableCollection<OperatorVM>();
            foreach (var opr in OperatorDataService.GetActives(SoheilEntityType.Activities, CurrentActivity.Id))
            {
                allVms.Add(new OperatorVM(opr, Access, OperatorDataService));
            }
            AllItems = new ListCollectionView(allVms);

            IncludeCommand = new Command(Include, CanInclude);
            ExcludeCommand = new Command(Exclude, CanExclude);
        }
Exemple #3
0
        private void InitializeData()
        {
            UnitOfWork = new SoheilEdmContext();
            OperatorDataService = new OperatorDataService(UnitOfWork);
            OperatorDataService.OperatorAdded += OnOperatorAdded;

            ColumnHeaders = new List<ColumnInfo> 
            { 
                new ColumnInfo("Code",0), 
                new ColumnInfo("Name",1), 
                new ColumnInfo("Status",2) ,
                new ColumnInfo("Mode",3,true) 
            };

            AddCommand = new Command(Add, CanAdd);RefreshCommand = new Command(CreateItems);
            AddGroupCommand = new Command(Add, CanAddGroup);
            ViewCommand = new Command(View, CanView);
            CreateItems(null);
        }
Exemple #4
0
        private void InitializeData()
        {
            UnitOfWork = new SoheilEdmContext();
            CostCenterDataService = new CostCenterDataService(UnitOfWork);
            MachineDataService = new MachineDataService(UnitOfWork);
            StationDataService = new StationDataService(UnitOfWork);
            OperatorDataService = new OperatorDataService(UnitOfWork);
            ActivityDataService = new ActivityDataService(UnitOfWork);
            WarehouseDataService = new PartWarehouseDataService(UnitOfWork);

            CostDataService = new CostDataService(UnitOfWork);
            CostDataService.CostAdded += OnCostAdded;
            CostCenterDataService.CostCenterAdded += OnCostCenterAdded;

            ColumnHeaders = new List<ColumnInfo> 
            { 
                new ColumnInfo("Description",0), 
                new ColumnInfo("CostType",1,true), 
                new ColumnInfo("SelectedCostSource","txtCostSource",2,true), 
                new ColumnInfo("CostValue","txtCost",3,true),
                new ColumnInfo("Mode",4,true) 
            };

            AddCommand = new Command(Add, CanAdd);RefreshCommand = new Command(CreateItems);
            AddGroupCommand = new Command(AddGroup);
            ViewCommand = new Command(View, CanView);

            var machineViewModels = new ObservableCollection<MachineInfoVM>();
            foreach (var entity in MachineDataService.GetAll())
            {
                machineViewModels.Add(new MachineInfoVM(entity));
            }
            Machines = new ListCollectionView(machineViewModels);
            var operatorViewModels = new ObservableCollection<OperatorInfoVM>();
            foreach (var entity in OperatorDataService.GetAll())
            {
                operatorViewModels.Add(new OperatorInfoVM(entity));
            }
            Operators = new ListCollectionView(operatorViewModels);
            var stationViewModels = new ObservableCollection<StationInfoVM>();
            foreach (var entity in StationDataService.GetAll())
            {
                stationViewModels.Add(new StationInfoVM(entity));
            }
            Stations = new ListCollectionView(stationViewModels);

            var activityViewModels = new ObservableCollection<ActivityInfoVM>();
            foreach (var entity in ActivityDataService.GetAll())
            {
                activityViewModels.Add(new ActivityInfoVM(entity));
            }
            Activities = new ListCollectionView(activityViewModels);

            var warehouseViewModels = new ObservableCollection<PartWarehouseInfoVM>();
            foreach (var entity in WarehouseDataService.GetAll())
            {
                warehouseViewModels.Add(new PartWarehouseInfoVM(entity));
            }
            Warehouses = new ListCollectionView(warehouseViewModels);

            CreateItems(null);
        }
Exemple #5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ProductVM"/> class from the model.
        /// </summary>
        /// <param name="entity">The model.</param>
        /// <param name="access"></param>
        /// <param name="dataService"></param>
        public OperatorVM(Operator entity, AccessType access, OperatorDataService dataService)
            : base(access)
        {
            InitializeData(dataService);
            _model = entity;

        }
Exemple #6
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ProductGroupVM"/> class initialized with default values.
 /// </summary>
 public OperatorVM(AccessType access, OperatorDataService dataService):base(access)
 {
     InitializeData(dataService);
 }
Exemple #7
0
 public static Operator CreateNew(OperatorDataService dataService)
 {
     int id = dataService.AddModel(new Operator { Name = "جدید", Code = string.Empty, CreatedDate = DateTime.Now, ModifiedDate = DateTime.Now });
     return dataService.GetSingle(id);
 }
Exemple #8
0
 private void InitializeData(OperatorDataService dataService)
 {
     OperatorDataService = dataService;
     SaveCommand = new Command(Save, CanSave);
 }