public async Task <ActionResult> SaveWebform(DataModel model)
{
if (model == null)
{
return(BadRequest()); //Pedido Inválido. Motivo: Modelo de dados vazio;
}
_Connection.DatabaseConnection(); //Ligação com o servidor de base de dados;
_Metadata.SetDatabase(_Connection.GetDatabase());
_Data.SetDatabase(_Connection.GetDatabase()); //Instanciar a ligação entre o serviço e o servidor de base de dados;
DataModel dataModel = null; //Objeto do tipo dataModel;
string id = string.Empty; //Armazena o valor correspondente ao ObjectID do modelo de dados;
/*
* Verifica o valor do Id do modelo de dados do tipo DataModel, se for null é um novo registo,
* se já tiver um valor associado é relativo a um registo já existente na base de dados;
*/
if (string.IsNullOrEmpty(model.Id))
{
_KeyGenerates.SetKey(); //Gerar um ObjectId, chave univoca, que identifica o modelo na colecção Data;
id = _KeyGenerates.GetKey();
}
else
{
id = model.Id;
}
/*
* Criar o objeto do tipo modelo DataModel para combinação ObjectId, ProcessId, ProcessVersion e ProcessBranch.
*/
dataModel = new DataModel()
{
Id = id,
ProcessId = model.ProcessId,
ProcessVersion = Convert.ToInt32(model.ProcessVersion),
ProcessBranch = model.ProcessBranch,
Data = model.Data,
Date = DateTime.Now.ToLocalTime()
};
/*
* Processo de criação / atualização do modelo de dados do tipo DataModel;
*/
if (string.IsNullOrEmpty(model.Id))
{
_Data.CreateDataModel(dataModel); //Registar o novo modelo de dados na colecção Data;
}
else
{
_Data.UpdateDataModel(dataModel); //Atualizar o modelo de dados na colecção Data;
}
return(await Task.Run(() => Redirect("/Data/GetLastProcessVersions/"))); //Redireccionar para a pégina raíz;
}
public async Task <ActionResult> PopulateStateCollection()
{
_Connection.DatabaseConnection();
var database = _Connection.GetDatabase();
_State.SetDatabase(database);
long documentNumber = await database.GetCollection <StateModel>("State").Find(s => true).CountDocumentsAsync();
ViewBag.Message = _Message.GetMessage(2);
ViewBag.EmptyCollection = "false";
if (documentNumber == 0)
{
List <StateModel> stateModels = new List <StateModel>();
_KeyId.SetKey();
StateModel active = new StateModel()
{
Id = _KeyId.GetKey(),
Value = true,
Description = "Active"
};
stateModels.Add(active);
_KeyId.SetKey();
StateModel inactive = new StateModel()
{
Id = _KeyId.GetKey(),
Value = false,
Description = "Inactive"
};
stateModels.Add(inactive);
_State.CreateState(stateModels);
ViewBag.Message = _Message.GetMessage(4);
ViewBag.EmptyCollection = "true";
}
List <StateModel> states = _State.GetStateModels();
return(await Task.Run(() => View("PopulateStateCollection", states)));
}
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 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")));
}