Example #1
0
 public string Delete(string FieldId)
 {
     if (string.IsNullOrEmpty(FieldId))
     {
         return(NotFound().StatusCode.ToString());
     }
     _Connection.DatabaseConnection();
     _Field.SetDatabase(_Connection.GetDatabase());
     return(_Field.DeleteField(FieldId));
 }
        private async Task EnsureFieldDeleted()
        {
            var fields = await service.GetAllFields();

            fields.ForEach(ob => {
                if (ob.Name.Equals(fieldLabel))
                {
                    service.DeleteField(ob.Id);
                }
            });
        }
Example #3
0
        public async Task DeleteFieldTest()
        {
            Workspace workspace = await CreateWorkspace();

            Component component = await CreateComponent(workspace);

            Field fieldTemplate = CreateFieldTemplate(component);

            Field result = await service.CreateField(fieldTemplate);

            await service.DeleteField(result.Id);

            try
            {
                await service.GetFieldById(result.Id);
                await DeleteWorkspace(workspace);

                Assert.Fail("Expected the Field to be deleted.");
            }
            catch (Refit.ApiException e)
            {
                Assert.AreEqual(System.Net.HttpStatusCode.NotFound, e.StatusCode);
            }
            await DeleteWorkspace(workspace);
        }
Example #4
0
        public IActionResult DeleteField(int id)
        {
            var fieldUserId = _fieldService.GetFieldById(id).UserId;

            if (fieldUserId != userId)
            {
                return(RedirectToAction("Index"));
            }
            _fieldService.DeleteField(id);
            return(RedirectToAction("Index"));
        }
        public async Task <ActionResult> Confirm(string id)
        {
            if (id == null)
            {
                return(BadRequest());
            }

            _Connection.DatabaseConnection();
            _Metadata.SetDatabase(_Connection.GetDatabase());
            _Field.SetDatabase(_Connection.GetDatabase());
            _Properties.SetDatabase(_Connection.GetDatabase());
            _Log.SetDatabase(_Connection.GetDatabase());

            //Obter os ids dos campos anexos a um processo;
            List <string> fields = _Metadata.GetProcessFieldsID(id);

            foreach (var field in fields)
            {
                FieldModel fieldModel = _Field.GetField(field);
                //Obter os ids das propriedades de um campo pertencente a um processo;
                _Properties.DeleteProperties(fieldModel.Properties); //Apaga na base de dados as propriedades existentes num campo;
                _Field.DeleteField(field);                           //Apaga na base de dados os campos existentes num processo;
            }

            /*
             * -------------------------------------------------------------------------------------
             * Log section
             * -------------------------------------------------------------------------------------
             */
            MetadataModel metadataModel = _Metadata.GetMetadata(id);

            _KeyID.SetKey(); //Generates a log model object id (unique key)
            _Log.CreateProcessLog(_KeyID.GetKey(), id, metadataModel.Name, metadataModel.Version, "Delete");
            //--------------------------------------------------------------------------------------

            _Metadata.DeleteMetadata(id); //Apaga na base de dados o processo propriamente dito;

            return(await Task.Run(() => RedirectToAction("Read", "Metadata")));
        }