/// <summary>
/// Create a lookup table code mask row
/// </summary>
/// <param name="ltDataSet">SvcLookupTable.LookupTableDataSet object</param>
/// <param name="structLevel">Level of the code mask</param>
/// <param name="maskSequence">Mask sequence type</param>
/// <param name="levelLength">Number of characters in this level</param>
/// <param name="separator">Code mask separator character for this level</param>
/// <returns>LookupTableMasksRow</returns>
private SvcLookupTable.LookupTableDataSet.LookupTableMasksRow CreateLookupTableMasksRow(
SvcLookupTable.LookupTableDataSet ltDataSet,
int structLevel,
byte maskSequence,
int levelLength,
string separator)
{
SvcLookupTable.LookupTableDataSet.LookupTableMasksRow ltMaskRow =
ltDataSet.LookupTableMasks.NewLookupTableMasksRow();
ltMaskRow.LT_UID = ltDataSet.LookupTables[0].LT_UID;
ltMaskRow.LT_MASK_STRUCT_LEVEL = structLevel;
ltMaskRow.LT_MASK_STRUCT_TYPE_ENUM = maskSequence;
ltMaskRow.LT_MASK_STRUCT_LENGTH = levelLength;
ltMaskRow.LT_MASK_VALUE_SEPARATOR = separator;
return(ltMaskRow);
}
/// <summary>
/// Metodo para criar as Lookuptable e suas dependencias
/// </summary>
/// <param name="pwaDestino">Destino</param>
/// <param name="itemRow">Item CustomField</param>
/// <param name="ds">Data Set LookupTable</param>
public void CreateLooukupTable(string pwaOrigem, string pwaDestino, string pLT_NAME)
{
try
{
//verificando se já existe a lookuptable no destino
dsLookupTableDestino = GetLookupTable(pwaDestino);
DataRow[] dataRowDestino = dsLookupTableDestino.Tables[0].Select("LT_NAME = '" + pLT_NAME + "'");
if (dataRowDestino.Count() > 0)
{
return;
}
if (dsLookupTableOrigem == null)
{
dsLookupTableOrigem = GetLookupTable(pwaOrigem);
}
DataRow[] dataRow = dsLookupTableOrigem.Tables[0].Select("LT_NAME = '" + pLT_NAME + "'");
SvcLookupTable.LookupTableDataSet ltDS = new LookupTableDataSet();
SvcLookupTable.LookupTableClient clientLookupTable = new LookupTableClient(Binding, endPointAdress(pwaDestino, "/_vti_bin/psi/LookupTable.asmx"));
clientLookupTable.ClientCredentials.Windows.ClientCredential = new NetworkCredential(this.User, this.PassWord, this.Domain);
foreach (SvcLookupTable.LookupTableDataSet.LookupTablesRow item in dataRow)
{
SvcLookupTable.LookupTableDataSet.LookupTablesRow ltRow = ltDS.LookupTables.NewLookupTablesRow();
Guid LT_UID = Guid.NewGuid();
ltRow.LT_UID = LT_UID;
ltRow.LT_FILL_ALL_LEVELS = item.LT_FILL_ALL_LEVELS;
ltRow.LT_NAME = item.LT_NAME;
if (!item.IsAPP_ENTITY_UIDNull())
{
ltRow.APP_ENTITY_UID = item.APP_ENTITY_UID;
}
if (!item.IsLT_PRIMARY_LCIDNull())
{
ltRow.LT_PRIMARY_LCID = item.LT_PRIMARY_LCID;
}
if (!item.IsLT_SORT_ORDER_ENUMNull())
{
ltRow.LT_SORT_ORDER_ENUM = item.LT_SORT_ORDER_ENUM;
}
ltDS.LookupTables.Rows.Add(ltRow);
foreach (SvcLookupTable.LookupTableDataSet.LookupTableMasksRow itemMaskRow in dsLookupTableOrigem.LookupTableMasks.Select("LT_UID = '" + item.LT_UID + "'"))
{
SvcLookupTable.LookupTableDataSet.LookupTableMasksRow ltMasksRow = ltDS.LookupTableMasks.NewLookupTableMasksRow();
foreach (DataColumn itemColumn in dsLookupTableOrigem.LookupTableMasks.Columns)
{
if (!ltDS.LookupTableMasks.Columns.Contains(itemColumn.ToString()))
{
continue;
}
if (itemColumn.ToString() == "LT_UID")
{
ltMasksRow[itemColumn.ToString()] = LT_UID;
continue;
}
if (itemMaskRow[itemColumn.ToString()] != null && !itemColumn.ReadOnly)
{
ltMasksRow[itemColumn.ToString()] = itemMaskRow[itemColumn.ToString()];
}
}
//ltMasksRow.LT_MASK_STRUCT_LEVEL = itemMaskRow.LT_MASK_STRUCT_LEVEL;
//ltMasksRow.LT_MASK_STRUCT_TYPE_ENUM = itemMaskRow.LT_MASK_STRUCT_TYPE_ENUM;
//ltMasksRow.LT_MASK_STRUCT_LENGTH = itemMaskRow.LT_MASK_STRUCT_LENGTH;
//ltMasksRow.LT_MASK_VALUE_SEPARATOR = itemMaskRow.LT_MASK_VALUE_SEPARATOR;
ltDS.LookupTableMasks.Rows.Add(ltMasksRow);
}
foreach (SvcLookupTable.LookupTableDataSet.LookupTableTreesRow itemTreesRow in dsLookupTableOrigem.LookupTableTrees.Select("LT_UID = '" + item.LT_UID + "'"))
{
//ltTreesRow.LT_UID = ltDS.LookupTables[0].LT_UID;
SvcLookupTable.LookupTableDataSet.LookupTableTreesRow ltTreesRow = ltDS.LookupTableTrees.NewLookupTableTreesRow();
foreach (DataColumn itemColumn in dsLookupTableOrigem.LookupTableTrees.Columns)
{
if (!ltDS.LookupTableTrees.Columns.Contains(itemColumn.ToString()))
{
continue;
}
//if (itemColumn.ToString() == "LT_STRUCT_UID")
//{
// ltTreesRow[itemColumn.ToString()] = Guid.NewGuid();
// continue;
//}
if (itemColumn.ToString() == "LT_UID")
{
ltTreesRow[itemColumn.ToString()] = LT_UID;
continue;
}
if (itemTreesRow[itemColumn.ToString()] != null && !itemColumn.ReadOnly)
{
ltTreesRow[itemColumn.ToString()] = itemTreesRow[itemColumn.ToString()];
}
}
ltDS.LookupTableTrees.Rows.Add(ltTreesRow);
}
try
{
bool validateOnly = false;
bool autoCheckIn = true;
clientLookupTable.CreateLookupTables(ltDS, validateOnly, autoCheckIn);
}
catch (SoapException ex)
{
string errMess = "";
// Pass the exception to the PSClientError constructor to
// get all error information.
PSLibrary.PSClientError psiError = new PSLibrary.PSClientError(ex);
PSLibrary.PSErrorInfo[] psiErrors = psiError.GetAllErrors();
for (int j = 0; j < psiErrors.Length; j++)
{
errMess += psiErrors[j].ErrId.ToString() + "\n";
}
errMess += "\n" + ex.Message.ToString();
MessageBox.Show(errMess);
// Send error string to console or message box.
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Create a hierarchical text lookup table, with code masks and values.
/// </summary>
/// <param name="lookupTable">SvcLookupTable.LookupTable object</param>
/// <param name="ltName">Name of the lookup table</param>
/// <param name="maskSequence">Array of code mask sequences and separator characters</param>
/// <param name="maskValues"></param>
/// <param name="ltValues">Array of lookup table values: Name, description, level, default</param>
/// <param name="ltRowDefaultUid">GUID of default value (out)</param>
/// <returns>GUID of lookup table</returns>
public Guid CreateLookupTable(
SvcLookupTable.LookupTable lookupTable,
string ltName,
byte[] maskSequence,
string[,] maskValues,
string[,] ltValues,
out Guid ltRowDefaultUid)
{
// Além região variáveis método, há três regiões
// Com um bloco try-catch:
// 1. Criar linhas de tabela de pesquisa com máscaras de código em um LookupTableDataSet
// 2 Adicionar valores herarchical para cada linha na tabela de pesquisa
// 3. CreateLookupTables chamada com o LookupTableDataSet
const string ANY = "any";
const string DEFAULT = "default";
#region Method variables
int levelLength;
string sLevelLength;
bool error = false;
// Save the return GUIDS for lookup table and default value (if any)
Guid[] returnIds = new Guid[2];
int numLtRows = ltValues.Length / 4; // There are 4 strings for each lookup table row
int maxLevels = maskValues.Length / 2; // There are 2 strings for each mask level
if (maxLevels != maskSequence.Length || maxLevels > 5)
{
// Error: The number of rows in the maskSequence and maskValues arrays must be the same.
// The hierarchical levels can't be more than five levels deep.
ltRowDefaultUid = Guid.Empty;
return(Guid.Empty);
}
int[] parentIndex = new int[numLtRows]; // Index of each lookup table row parent
Guid[] parentUid = new Guid[numLtRows]; // Parent GUIDs of lookup table tree rows
for (int i = 0; i < numLtRows; i++)
{
parentIndex[i] = Convert.ToInt32(ltValues[i, 2]);
}
SvcLookupTable.LookupTableDataSet lookupTableDataSet =
new SvcLookupTable.LookupTableDataSet();
#endregion
#region Criar uma linha da tabela de pesquisa com máscaras de código
try
{
//Criar uma linha da tabela de pesquisa a partir da instância LookupTableDataSet
SvcLookupTable.LookupTableDataSet.LookupTablesRow lookupTableRow =
lookupTableDataSet.LookupTables.NewLookupTablesRow();
Guid lookupTableGuid = Guid.NewGuid();
// Set the lookup table ID
returnIds[0] = lookupTableGuid;
lookupTableRow.LT_UID = lookupTableGuid;
lookupTableRow.LT_NAME = ltName;
lookupTableRow.LT_SORT_ORDER_ENUM =
(byte)PSLibrary.LookupTables.SortOrder.Ascending;
lookupTableDataSet.LookupTables.Rows.Add(lookupTableRow);
// Create the code mask and rows
SvcLookupTable.LookupTableDataSet.LookupTableMasksDataTable masksDataTable =
new SvcLookupTable.LookupTableDataSet.LookupTableMasksDataTable();
SvcLookupTable.LookupTableDataSet.LookupTableMasksRow ltMasksRow =
masksDataTable.NewLookupTableMasksRow();
for (int level = 0; level < maxLevels; level++)
{
sLevelLength = maskValues[level, 0];
if (string.Compare(sLevelLength, ANY, true) == 0)
{
levelLength = PSLibrary.LookupTables.ANY_LENGTH_SEQUENCE;
}
else
{
levelLength = Convert.ToInt32(maskValues[level, 0]);
}
ltMasksRow = CreateLookupTableMasksRow(
lookupTableDataSet,
level + 1,
maskSequence[level],
levelLength,
maskValues[level, 1]);
lookupTableDataSet.LookupTableMasks.Rows.Add(ltMasksRow);
}
}
catch (DataException ex)
{
// Add exception handler for ex
error = true;
}
catch (SoapException ex)
{
// Add exception handler for ex
error = true;
}
#endregion
#region Add values to each row
// Add the lookup table values
try
{
SvcLookupTable.LookupTableDataSet.LookupTableTreesRow ltTreeRow =
lookupTableDataSet.LookupTableTrees.NewLookupTableTreesRow();
if (!error)
{
int thisNode;
int nextNode;
int indexDiff; // Difference in levels between nodes
int rowLevel; // Level of the current row
Guid rowUid; // GUID of the current level
Guid[] previousLevelUid = new Guid[4]; // GUIDs of up to five previous levels
// [0]: level 1; ... ; [4]: level 5
parentUid[0] = Guid.Empty; // Initialize the first parentUid
for (int row = 0; row < numLtRows; row++)
{
rowUid = Guid.NewGuid();
thisNode = row;
nextNode = thisNode + 1;
rowLevel = parentIndex[row];
previousLevelUid[rowLevel] = rowUid; // Reset the previous level
ltTreeRow = AddLookupTableValues(
lookupTableDataSet,
parentUid[row], // Parent GUID
rowUid, // Current row GUID
ltValues[row, 0], // Value
ltValues[row, 1] // Description
);
// Set the parentUid of the next node.
if (row < numLtRows - 1)
{
if (parentIndex[nextNode] == 0)
{
parentUid[nextNode] = Guid.Empty;
}
else
{
indexDiff = parentIndex[nextNode] - parentIndex[thisNode];
switch (indexDiff)
{
case 1:
parentUid[nextNode] = rowUid;
break;
case 0:
parentUid[nextNode] = parentUid[thisNode];
break;
case -1:
case -2:
case -3:
indexDiff -= 1;
parentUid[nextNode] = previousLevelUid[rowLevel + indexDiff];
break;
}
}
}
// Check for the default GUID
if (ltValues[row, 3] == DEFAULT)
{
returnIds[1] = rowUid;
}
lookupTableDataSet.LookupTableTrees.Rows.Add(ltTreeRow);
}
}
}
catch (SoapException ex)
{
// Add exception handler for ex
error = true;
}
catch (Exception ex)
{
// Add exception handler for ex
error = true;
}
#endregion
#region Create and return the lookup table
try
{
if (!error)
{
bool validateOnly = false;
bool autoCheckIn = true;
lookupTable.CreateLookupTables(lookupTableDataSet,
validateOnly, autoCheckIn);
}
}
catch (SoapException ex)
{
string errMess = "";
// Pass the exception to the PSClientError constructor to get
// all error information.
PSLibrary.PSClientError psiError = new PSLibrary.PSClientError(ex);
PSLibrary.PSErrorInfo[] psiErrors = psiError.GetAllErrors();
for (int j = 0; j < psiErrors.Length; j++)
{
errMess += psiErrors[j].ErrId.ToString() + "\n";
}
errMess += "\n" + ex.Message.ToString();
// Send error string to console or message box.
error = true;
}
if (error)
{
returnIds[0] = Guid.Empty;
returnIds[1] = Guid.Empty;
}
ltRowDefaultUid = returnIds[1];
return(returnIds[0]);
#endregion
}
