Пример #1
0
        /// <inheritdoc/>
        protected override async Task <bool> ProtectedHandleAsync(ClearObjectsCommand request, CancellationToken cancellationToken)
        {
            if (request.RefDate.HasValue)
            {
                var refDate  = request.RefDate.Value.ToUniversalTime();
                var entities = Context.ObjectRepository.GetQuery().Where(e => e.CreatedDate <= refDate).ToList();
                foreach (var entity in entities)
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    var command = new DeleteObjectCommand()
                    {
                        Id = entity.Id.ToString()
                    };

                    await mediator.Send(command, cancellationToken);
                }
            }
            else
            {
                if (fileSystem.Directory.Exists(configuration.Options.WorkingDirectory))
                {
                    var directories = fileSystem.Directory.EnumerateDirectories(configuration.Options.WorkingDirectory);
                    foreach (var directory in directories)
                    {
                        fileSystem.Directory.Delete(directory, true);
                    }
                }
            }

            await Task.CompletedTask;

            return(true);
        }
Пример #2
0
        public ICommandResult Handle(DeleteObjectCommand command)
        {
            ICommandResult result = new CommandResult();

            _loggingService.Log(this.GetType(), ELogType.Neutral, ELogLevel.Debug, new { command.Object, command.RequestHost }, "ObjectCommandHandler.Handle(Delete)");

            try
            {
                if (_objectRepository.CheckExists(command.Object))
                {
                    if (_objectRepository.Delete(command.Object))
                    {
                        result = new CommandResult(200);
                    }
                }

                else if (_objectRepository.Valid)
                {
                    result = new CommandResult(400, new Notification("Object", "Could not be found"));
                }
            }
            catch (Exception e)
            {
                _loggingService.Log(this.GetType(), ELogType.Neutral, ELogLevel.Error, new { command.Object, command.RequestHost }, e);
            }

            return(result);
        }
Пример #3
0
 private void OnSelectedChanged(object sender, ValueChangedEventArgs <ObjectBase> valueChangedEventArgs)
 {
     DeleteObjectCommand.RaiseCanExecuteChanged();
     TranslateObjectCommand.RaiseCanExecuteChanged();
     ScaleObjectCommand.RaiseCanExecuteChanged();
     RotateObjectCommand.RaiseCanExecuteChanged();
 }
        public void LoadCommand(String connectionString, String outputDirectoryPath, String namespaceName, String databaseKey)
        {
            this.Commands.Clear();

            var sv = this;
            var sc = _SchemaData;
            sc.NamespaceName = namespaceName;
            sc.DatabaseKey = databaseKey;

            DatabaseSchemaReader db = DatabaseSchemaReader.Create(sc.DatabaseServer, connectionString);

            var tt = db.GetTables();
            var ss = db.GetStoredProcedures();
            var uu = db.GetUserDefinedTableTypes();

            {
                var cm = new ImportTableCommand(sc, connectionString);
                cm.Names.AddRange(tt.Where(el => this.ImportAllObject == true || el.LastAlteredTime > sc.LastExecuteTimeOfImportTable).Select(el => el.Name));
                cm.Names.RemoveAll(name => sc.IgnoreObjects.Exists(el => el.Name == name));
                sv.Commands.Add(cm);
            }
            {
                var cm = new ImportStoredProcedureCommand(sc, connectionString);
                cm.Names.AddRange(ss.Where(el => this.ImportAllObject == true || el.LastAlteredTime > sc.LastExecuteTimeOfImportStoredProcedure).Select(el => el.Name));
                cm.Names.RemoveAll(name => sc.IgnoreObjects.Exists(el => el.Name == name));
                sv.Commands.Add(cm);
            }
            {
                var cm = new ImportUserDefinedTableTypeCommand(sc, connectionString);
                cm.Names.AddRange(uu.Where(el => this.ImportAllObject == true || el.LastAlteredTime > sc.LastExecuteTimeOfImportUserDefinedTableType).Select(el => el.Name));
                cm.Names.RemoveAll(name => sc.IgnoreObjects.Exists(el => el.Name == name));
                sv.Commands.Add(cm);
            }

            {
                var cm = new DeleteObjectCommand(outputDirectoryPath, sc, connectionString);
                cm.Started += (o, ea) =>
                {
                    var tNames = db.GetTables().Select(el => el.Name).ToList();
                    var sNames = db.GetStoredProcedures().Select(el => el.Name).ToList();
                    var uNames = db.GetUserDefinedTableTypes().Select(el => el.Name).ToList();
                    cm.TableNames.AddRange(sc.Tables.Where(el => tNames.Contains(el.Name) == false).Select(el => el.Name));
                    cm.StoredProcedures.AddRange(sc.StoredProcedures.Where(el => sNames.Contains(el.Name) == false).Select(el => el.Name));
                    cm.UserDefinedTableTypes.AddRange(sc.UserDefinedTableTypes.Where(el => uNames.Contains(el.Name) == false).Select(el => el.Name));
                };
                sv.Commands.Add(cm);
            }

            {
                var cm = new GenerateSourceCodeCommand(outputDirectoryPath, sc);
                cm.Started += (o, ea) =>
                {
                    cm.Tables.AddRange(sc.Tables);
                    cm.StoredProcedures.AddRange(sc.StoredProcedures);
                    cm.UserDefinedTableTypes.AddRange(sc.UserDefinedTableTypes);
                };
                sv.Commands.Add(cm);
            }
        }
Пример #5
0
        /// <inheritdoc/>
        public void DeleteObject(string bucketName, string key)
        {
            var cmd = DeleteObjectCommand.Create(_serviceClient, _endpoint,
                                                 CreateContext(HttpMethod.Delete, bucketName, key),
                                                 bucketName, key);

            cmd.Execute();
        }
Пример #6
0
        public void DeleteObject(string id)
        {
            var mediator = GetService <IMediator>();
            var command  = new DeleteObjectCommand()
            {
                Id = id
            };

            mediator.Send(command);
        }
Пример #7
0
        public BucketEntryViewModel(BucketContentViewModel bucketContentViewModel, IBucketService bucketService, IObjectService objectService)
        {
            _bucketContentViewModel = bucketContentViewModel;

            DownloadObjectCommand = new DownloadObjectCommand(bucketContentViewModel, bucketService, objectService, bucketContentViewModel.BucketName);
            DeleteObjectCommand   = new DeleteObjectCommand(bucketService, objectService);
            CancelUploadCommand   = new CancelUploadCommand(bucketService, objectService);
            CancelDownloadCommand = new CancelDownloadCommand(bucketService, objectService);
            ShowErrorCommand      = new ShowErrorCommand();
        }
Пример #8
0
        /// <inheritdoc/>
        public void DeleteObject(string bucketName, string key)
        {
            var cmd = DeleteObjectCommand.Create(GetServiceClient(), _endpoint,
                                                 CreateContext(HttpMethod.Delete, bucketName, key),
                                                 bucketName, key);

            using (cmd.Execute())
            {
                // Do nothing
            }
        }
Пример #9
0
        /// <summary>
        /// 删除对象
        /// </summary>
        /// <param name="bucket"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task <OssResult <DeleteObjectResult> > DeleteObjectAsync(BucketInfo bucket, string key)
        {
            var cmd = new DeleteObjectCommand(_requestContext, bucket, key);

            var result = await cmd.ExecuteAsync(_client);

            if (!result.IsSuccess)
            {
                _logger.LogError($"Failed in OssClient.{nameof(PutObjectAsync)}(). \nBucket: {bucket.BucketName}\nPath: {key}");
            }

            return(result);
        }
Пример #10
0
        public void DeleteObjects(ICommandManager manager)
        {
            List <IObject> objForDel = new List <IObject>();

            foreach (var obj in _objects)
            {
                if (obj.IsChecked)
                {
                    objForDel.Add(obj);
                }
            }
            var command = new DeleteObjectCommand(_objects, objForDel);

            manager.Execute(command);
        }
Пример #11
0
        public void DeleteObjectTest()
        {
            AddObjectToSketchWorldRootCommand addCommand = new AddObjectToSketchWorldRootCommand(this.StrokeSketchObject, this.SketchWorld);

            Invoker.ExecuteCommand(addCommand);
            Assert.IsTrue(this.StrokeSketchObject.gameObject.activeInHierarchy);
            Assert.IsTrue(this.StrokeSketchObject.transform.IsChildOf(this.SketchWorld.transform));
            Assert.IsTrue(this.StrokeSketchObject.transform.parent.name == "RootSketchObjectGroup");

            DeleteObjectCommand deleteCommand = new DeleteObjectCommand(this.StrokeSketchObject, this.SketchWorld);

            Invoker.ExecuteCommand(deleteCommand);
            Assert.IsFalse(this.StrokeSketchObject.gameObject.activeInHierarchy);
            Assert.IsTrue(this.StrokeSketchObject.transform.IsChildOf(this.SketchWorld.transform));
            Assert.IsTrue(this.StrokeSketchObject.transform.parent.name == "Deleted Bin");
        }
Пример #12
0
        public void deleteObjectTest()
        {
            List <AppLayer.Object> myObjects = new List <AppLayer.Object>();
            ClassDiagram           myObject  = new ClassDiagram(0, 0, 100, 100);

            myObjects.Add(myObject);

            DeleteObjectCommand myCommand = new DeleteObjectCommand(myObject, ref myObjects);

            myCommand.execute();

            if (myObjects.Count != 0)
            {
                Assert.Fail();
            }
        }
        public DeleteObjectCommandService(String outputDirectoryPath
            , SchemaData schemaData
            , String connectionString
            , IEnumerable<String> tableNames
            , IEnumerable<String> storedProcedureNames
            , IEnumerable<String> userDefinedTableTypeNames)
        {
            this._SchemaData = schemaData;
            var sc = this._SchemaData;

            var cm = new DeleteObjectCommand(outputDirectoryPath, sc, connectionString);
            cm.TableNames.AddRange(tableNames);
            cm.StoredProcedures.AddRange(storedProcedureNames);
            cm.UserDefinedTableTypes.AddRange(userDefinedTableTypeNames);

            this.Commands.Add(cm);
        }
Пример #14
0
        public CommandResult Delete(Guid id)
        {
            DeleteObjectCommand command = new DeleteObjectCommand()
            {
                Object = id
            };

            command.setRequestHost(HttpContext.Request.Host.ToString());

            _loggingService.Log(this.GetType(), ELogType.Input, ELogLevel.Info, new { Object = this.User.Identity.Name, Path = this.Request.Path, Method = this.Request.Method });

            CommandResult result = (CommandResult)_objectHandler.Handle(command);

            _loggingService.Log(this.GetType(), ELogType.Output, ELogLevel.Info, new { Object = this.User.Identity.Name, Path = this.Request.Path, Method = this.Request.Method, Code = this.Response.StatusCode });

            HttpContext.Response.StatusCode = result.Code;

            return(result);
        }
Пример #15
0
        /// <summary>
        /// 删除对象
        /// </summary>
        /// <param name="bucket"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task <OssResult <DeleteObjectResult> > DeleteObjectAsync(BucketInfo bucket, string key)
        {
            var cmd = new DeleteObjectCommand(_requestContext, bucket, key);

            return(await cmd.ExecuteAsync());
        }