public async void CreateFieldTest()
{
Workspace workspace = await CreateWorkspace();
Component component = await CreateComponent(workspace);
Field fieldTemplate = CreateFieldTemplate(component);
Field result = await service.CreateField(fieldTemplate);
Assert.NotNull(result.Id);
await DeleteWorkspace(workspace);
}
public async Task CreateFieldTest()
{
await EnsureFieldDeleted();
Workspace workspace = await CreateWorkspace();
Component component = await CreateComponent(workspace);
Field fieldTemplate = CreateFieldTemplate(component);
Console.WriteLine(fieldTemplate);
Field result = await service.CreateField(fieldTemplate);
Assert.NotNull(result.Id);
await DeleteWorkspace(workspace);
}
public async Task <ActionResult> AddField(ViewFieldModel model)
{
//Defines the properties model key
_KeyId.SetKey(); //Sets a new properties ObjectID collection;
string propertiesId = _KeyId.GetKey();
//First must create properties model;
PropertiesModel properties = new PropertiesModel()
{
ID = propertiesId,
Size = Convert.ToInt32(model.Size),
Value = model.Value,
Maxlength = Convert.ToInt32(model.Maxlength),
Required = Convert.ToBoolean(model.Required)
};
_KeyId.SetKey(); //Sets a new properties ObjectID collection;
string fieldId = _KeyId.GetKey();
//Third creates field model
FieldModel field = new FieldModel()
{
Id = fieldId,
Name = model.Name,
Type = model.Type,
Properties = propertiesId,
Date = DateTime.Now.ToLocalTime()
};
_Connection.DatabaseConnection();
_Properties.SetDatabase(_Connection.GetDatabase());
_Properties.CreateProperties(properties);
_Field.SetDatabase(_Connection.GetDatabase());
_Field.CreateField(field);
_Metadata.SetProcessVersion(model.ProcessID);
_Metadata.AddFieldToProcess(model.ProcessID, fieldId);
return(await Task.Run(() => RedirectToAction("Read", "Field", new { ProcessId = model.ProcessID })));
}
public ActionResult AddField(FieldInputModel fieldInput, int parentId)
{
if (ModelState.IsValid)
{
fieldInput.ParentId = parentId;
_fieldService.CreateField(fieldInput.ToBllField());
if (Url.IsLocalUrl(HttpContext.Request.UrlReferrer.AbsolutePath))
{
return(Redirect(HttpContext.Request.UrlReferrer.AbsolutePath));
}
return(RedirectToAction("Field", "Knowledge", new { id = parentId }));
}
else
{
ModelState.AddModelError("", "Incorrect input.");
var field = _fieldService.GetField(parentId)
?.ToPlField();
if (field == null)
{
return(View("Error"));
}
var knowledgeFieldViewModel = new KnowledgeFieldViewModel()
{
Field = field
};
knowledgeFieldViewModel.SkillInput.FieldId = parentId;
knowledgeFieldViewModel.FieldInput = fieldInput;
return(View("Field", knowledgeFieldViewModel));
}
}
public async Task <ActionResult> UpdateProcess(MetadataModel viewModel)
{
if (viewModel == null) //Se o modelo de dados estiver vazio, redirecciona para a mesma página;
{
return(await Task.Run(() => RedirectToAction("Update", "Metadata")));
}
_Connection.DatabaseConnection();
_Field.SetDatabase(_Connection.GetDatabase());
_Metadata.SetDatabase(_Connection.GetDatabase());
_GetBranchById.SetDatabase(_Connection.GetDatabase());
_GetStateById.SetDatabase(_Connection.GetDatabase());
_Properties.SetDatabase(_Connection.GetDatabase());
_Log.SetDatabase(_Connection.GetDatabase());
//1º Passo - Obter os objetos FieldModel e PropertiesModel agregados à versão anterior e passados no Modelo de dados MetadataModel;
//-----------------------------------------------------
//Sistema independente - Utils
//-----------------------------------------------------
List <string> fieldIdKeys = new List <string>(); //Armazena a lista de novos ids dos campos do processo atualizado;
List <FieldModel> fieldClones = new List <FieldModel>(); //Armazena os campos clonados da versão anterior
foreach (var field in viewModel.Field)
{
FieldModel model = _Field.GetField(field);
fieldClones.Add(model);
}
foreach (var fieldCloned in fieldClones)
{
PropertiesModel model = _Properties.GetProperties(fieldCloned.Properties);
_KeyID.SetKey(); //Gera um novo object id para criar uma nova coleção na tabela de propriedades;
model.ID = _KeyID.GetKey(); //Afecta o novo identificador object id ao modelo de dados properties;
_Properties.CreateProperties(model); //cria um novo modelo de dados do tipo propriedades;
fieldCloned.Properties = model.ID; //Afecta o id dessas propriedades criadas ao campo do novo processo
_KeyID.SetKey(); //Gera um novo object id para criar uma nova coleção na tabela de campos;
fieldCloned.Id = _KeyID.GetKey(); //Afecta o novo identificador object id ao modelo de dados properties;
fieldIdKeys.Add(fieldCloned.Id); //Armazena na lista de novas keys referentes aos campos clonados o id do campo clonado;
_Field.CreateField(fieldCloned); //cria um novo modelo de dados do tipo campos;
}
//-----------------------------------------------------
//2º Passo - obter a designação dos branches em que se encontra o processo;
List <string> branches = new List <string>();
foreach (var branch in viewModel.Branch)
{
branches.Add(_GetBranchById.GetBranchID(branch));
}
//3º Passo - Cria e armazena na base de dados uma nova versão do processo atualizado;
MetadataModel UpdatedMetadataModel = new MetadataModel()
{
Id = viewModel.Id,
Name = viewModel.Name,
Version = viewModel.Version,
Date = Convert.ToDateTime(viewModel.Date),
State = _GetStateById.GetStateID(viewModel.State),
Field = fieldIdKeys,
Branch = branches
};
/*
* -------------------------------------------------------------------------------------
* Log section
* -------------------------------------------------------------------------------------
*/
_KeyID.SetKey(); //Generates a log model object id (unique key)
_Log.CreateProcessLog(_KeyID.GetKey(), viewModel.Id, viewModel.Name, viewModel.Version, "Update");
//--------------------------------------------------------------------------------------
_Metadata.CreateMetadata(UpdatedMetadataModel); //armazena o processo na base de dados;
return(await Task.Run(() => RedirectToAction("Read", "Field", new { ProcessId = viewModel.Id })));
}
public JsonResult CreateNewField(string fieldName, int fieldTypeId)
{
FieldService.CreateField(fieldName, fieldTypeId);
return(GetDynamicJson(true));
}