public void iven_A_FieldNameType_When_I_Call_GetField_Then_The_Correct_Field_Is_Returned(FieldNameType fieldNameType)
{
//arrange
var fieldMock = new Mock <IField>();
var dataRecordMock = new Mock <IDataRecord>();
dataRecordMock.Setup(d => d.GetField(fieldNameType.FullName())).Returns(fieldMock.Object);
//act
var result = _sut.GetField(dataRecordMock.Object, fieldNameType);
//assert
Assert.AreEqual(fieldMock.Object, result);
}
public async Task <ActionResult> Read()
{
string processId = Request.Query["ProcessId"];
_Connection.DatabaseConnection();
_Field.SetDatabase(_Connection.GetDatabase());
_Metadata.SetDatabase(_Connection.GetDatabase());
_Branch.SetDatabase(_Connection.GetDatabase());
_State.SetDatabase(_Connection.GetDatabase());
List <FieldModel> fields = new List <FieldModel>(); //Armazena os campos existentes no processo;
//1º Passo - Obter o Metadata Model correspondente ao id fornecido;
MetadataModel metadata = _Metadata.GetMetadata(processId);
//2º Passo - Obter os Field Models agregados a cada processo;
if (metadata.Field.Count() > 0)
{
foreach (var field in metadata.Field)
{
fields.Add(_Field.GetField(field)); //Adiciona o modelo criado para cada campo (Field) a uma lista do tipo FieldModel;
}
}
//3º Passo - Injetar na página as informações relativas ao processo pai dos campos agregados;
ViewBag.ProcessId = metadata.Id;
ViewBag.ProcessName = metadata.Name;
ViewBag.processVersion = metadata.Version.ToString();
ViewBag.ProcessDate = metadata.Date.ToString().Substring(0, 10);
_State.ReadFromDatabase(metadata.State);
ViewBag.ProcessState = _State.GetStateDescription();
if (fields.Count == 0)
{
FieldModel defaultModel = new FieldModel()
{
Id = string.Empty,
Name = string.Empty,
Type = string.Empty,
Date = DateTime.Now.ToLocalTime(),
Properties = string.Empty
};
fields.Add(defaultModel);
}
return(await Task.Run(() => View("Read", fields)));
}
public ActionResult Field(int id)
{
ViewBag.UserVM = _userService.GetUserEntityByLogin(User.Identity.Name).ToPlUser();
var field = _fieldService.GetField(id)
?.ToPlField();
if (field == null)
{
return(HttpNotFound());
}
var knowledgeFieldViewModel = new KnowledgeFieldViewModel
{
Field = field,
SkillInput = { FieldId = id },
FieldInput = { ParentId = id },
ParentFields = _fieldService.GetFieldParents(id).Select(f => f.ToPlField()).Reverse().ToList()
};
return(View(knowledgeFieldViewModel));
}
public async Task <ActionResult> GetDetailsByVersion(string id)
{
_Connection.DatabaseConnection(); //Estabeleçe-se a conexão com a base de dados;
_Metadata.SetDatabase(_Connection.GetDatabase()); //Cria uma instância da base de dados no serviço;
_Field.SetDatabase(_Connection.GetDatabase()); //Cria uma instância da base de dados no serviço;
//Se o identificador não tiver qualquer valor armazenado, devolve um bad request;
if (id == null)
{
return(BadRequest());
}
//------------------------------------------
//Add - Pagination to Page (Phase 1)
//------------------------------------------
string pageNumber = Request.Query["Page"];
if (string.IsNullOrEmpty(pageNumber))
{
pageNumber = 1.ToString();
}
int pageIndex = Convert.ToInt32(pageNumber);
ViewBag.PageNumber = pageNumber; //Passa para a view o número da página;
ViewBag.Id = id; //Passa para a view o identificador do processo;
//------------------------------------------
//1º Passo - obter o MetadataModel;
MetadataModel metadata = _Metadata.GetMetadata(id);
//2ºPasso - Coverter o Id do estado para a sua descrição;
_GetStateById.ReadFromDatabase(metadata.State);
ViewBag.State = _GetStateById.GetStateDescription();
//3ºPasso - Agregar oas descrições dos branches ao qual o processo pertence numa string;
_GetBranchById.ReadFromDatabase(metadata.Branch);
ViewBag.Branches = _GetBranchById.GetBranches();
//4º Passo - obter o(s) FieldModel(s);
List <FieldModel> fields = new List <FieldModel>();
foreach (var fieldId in metadata.Field)
{
FieldModel field = _Field.GetField(fieldId);
fields.Add(field);
}
//------------------------------------------
//Add - Pagination to Page (Phase 2)
//------------------------------------------
_SetPagination.SetNumberOfModelsByPage(2);
Dictionary <int, List <FieldModel> > fieldsToDisplay = _SetPagination.SetModelsByPage(fields);
int NumberOfPages = fieldsToDisplay.Count();
ViewBag.NumberOfPages = NumberOfPages;
//------------------------------------------
//5º Passo . construir o modelo que permite efetuar o dsiplay do processo seleccionado através da sua versão;
ViewProcessModel viewModel = new ViewProcessModel()
{
Metadata = metadata,
Fields = fieldsToDisplay[pageIndex]
};
return(await Task.Run(() => View("GetDetailsByVersion", viewModel)));
}
public IDataValue GetFieldValue(IDataRecord dataRecord, FieldNameType fieldNameType)
{
return(_fieldService.GetField(dataRecord, fieldNameType).DataValue);
}
public async Task <ActionResult> GetStoredWebForm(string ObjectId, string ProcessId, string ProcessVersion, string ProcessBranch)
{
List <WebFormModel> webFormElements = new List <WebFormModel>();
//Se o modelo de dados for nulo, logo estamos perante um caso de pedido inválido (Bad Request)
if (string.IsNullOrEmpty(ProcessId))
{
return(BadRequest());
}
_Connection.DatabaseConnection();
//Chamadas aos serviços - Ligação à base de dados
_Metadata.SetDatabase(_Connection.GetDatabase());
_Field.SetDatabase(_Connection.GetDatabase());
_Properties.SetDatabase(_Connection.GetDatabase());
_Data.SetDatabase(_Connection.GetDatabase());
//Obter a lista de camposde um processo;
List <string> processFields = _Metadata.GetProcessFieldsID(ProcessId);
DataModel dataModel = _Data.GetDataModel(ObjectId, ProcessId, Convert.ToInt32(ProcessVersion), ProcessBranch);
//Valores para preenchimento de campos hidden no formulário gerado automaticamente;
ViewBag.ObjectId = ObjectId;
ViewBag.ProcessId = ProcessId;
ViewBag.ProcessVersion = ProcessVersion;
ViewBag.ProcessBranch = ProcessBranch;
string ProcessFields = string.Empty;
for (int j = 0; j < processFields.Count; j++)
{
FieldModel fieldModel = _Field.GetField(processFields.ElementAt(j));
if (j == processFields.Count - 1)
{
ProcessFields += fieldModel.Type;
}
else
{
ProcessFields += fieldModel.Type + " ";
}
PropertiesModel propertiesModel = _Properties.GetProperties(fieldModel.Properties);
WebFormModel webFormElement = new WebFormModel()
{
Type = fieldModel.Type,
Name = fieldModel.Name,
Size = propertiesModel.Size.ToString(),
Value = dataModel.Data.ElementAt(j),
Maxlength = propertiesModel.Maxlength.ToString(),
Required = propertiesModel.Required.ToString(),
Readonly = false
};
ViewBag.Readonly = "false"; //Vraiavel para controlo da visibilidade do submit button;
webFormElements.Add(webFormElement);
}
//Passar a lista de webform elements a uma classe que vai criar uma array com as linhas a serem renderizadas;
WebFormTemplate webFormTemplate = new WebFormTemplate(webFormElements);
List <string> fragments = webFormTemplate.Template();
string template = string.Empty;
for (int j = 0; j < fragments.Count; j++)
{
if (j == fragments.Count - 1)
{
template += fragments[j];
}
else
{
template += (fragments[j] + "|");
}
}
ViewBag.Template = template;
return(await Task.Run(() => View("WebFormGenerator")));
}
