public static void SetDateTimeRecord(SqlDataReader dr, string columnName, SqlDataRecord record, int ordinal)
{
if (dr[columnName] == DBNull.Value)
record.SetDBNull(ordinal);
else
record.SetDateTime(ordinal, Convert.ToDateTime(dr[columnName]));
}
protected static IEnumerable<SqlDataRecord> GenerateMetaPropertyTable(MetaObject o)
{
var metaFields = new List<SqlDataRecord>();
try
{
SqlMetaData[] metaData = new SqlMetaData[2];
metaData[0] = new SqlMetaData("FieldName", SqlDbType.VarChar, 30);
metaData[1] = new SqlMetaData("FieldValue", SqlDbType.VarChar, -1);
foreach (KeyValuePair<string, JToken> prop in o.MetaPropertiesObject)
{
SqlDataRecord record = new SqlDataRecord(metaData);
record.SetString(0, prop.Key);
// coming from the DB the value will be an object representing the field, with a "Value" key
// coming from the client the value will be a single value
var value = prop.Value.SelectToken("Value") ?? prop.Value;
if (value.Type == JTokenType.Null)
{
record.SetDBNull(1);
}
else
{
record.SetString(1, value.ToString());
}
metaFields.Add(record);
}
}
catch (Exception e)
{
}
return metaFields;
}
public static void PR_GER_FileInfo(SqlString nom_Caminho)
{
FileInfo _file = new FileInfo(nom_Caminho.Value);
List<SqlMetaData> colunas = new List<SqlMetaData>();
//new SqlMetaData("stringcol", SqlDbType.NVarChar, 128)
colunas.Add(new SqlMetaData("dat_Criacao", SqlDbType.DateTime));
colunas.Add(new SqlMetaData("dat_UltimoAcesso", SqlDbType.DateTime));
colunas.Add(new SqlMetaData("dat_UltimaEscrita", SqlDbType.DateTime));
colunas.Add(new SqlMetaData("ind_Existe", SqlDbType.Bit));
colunas.Add(new SqlMetaData("nom_Arquivo", SqlDbType.VarChar, 700));
colunas.Add(new SqlMetaData("nom_Diretorio", SqlDbType.VarChar, 700));
colunas.Add(new SqlMetaData("nom_Extensao", SqlDbType.VarChar, 700));
colunas.Add(new SqlMetaData("val_Tamanho", SqlDbType.BigInt));
SqlDataRecord record = new SqlDataRecord(colunas.ToArray());
BindFile(_file, record);
SqlContext.Pipe.Send(record);
}
public static void SetStringRecord_NullEmpty(SqlDataReader dr, string columnName, SqlDataRecord record, int ordinal)
{
if (dr[columnName] == DBNull.Value)
record.SetString(ordinal, "");
else
record.SetString(ordinal, Convert.ToString(dr[columnName]));
}
public static void spGetNewVestaErrands(SqlDateTime date)
{
DateTime d = date.Value;
String reqStr = String.Format("http://{0}/services/internalSite/errands/sendNewVestaErrandsMails?date={1}",
UserDefinedFunctions.fGetWapServerName(), d.ToString("s"));
SqlContext.Pipe.Send(reqStr);
HttpWebRequest rq = (HttpWebRequest)WebRequest.Create(reqStr);
rq.KeepAlive = false;
XmlDocument xdoc = new XmlDocument();
using(HttpWebResponse rs = (HttpWebResponse)rq.GetResponse())
using(Stream stream = rs.GetResponseStream())
xdoc.Load(stream);
XmlNode root = xdoc["result"];
SqlDataRecord rec = new SqlDataRecord(new SqlMetaData("id", SqlDbType.NVarChar, -1),
new SqlMetaData("text", SqlDbType.NVarChar, -1),
new SqlMetaData("creator", SqlDbType.NVarChar, -1),
new SqlMetaData("email", SqlDbType.NVarChar, -1)
);
SqlContext.Pipe.SendResultsStart(rec);
foreach(XmlNode ch in root.ChildNodes)
{
rec.SetValues(ch["id"].InnerText,
ch["text"].InnerText,
ch["creator"].InnerText,
ch["email"].InnerText
);
SqlContext.Pipe.SendResultsRow(rec);
}
SqlContext.Pipe.SendResultsEnd();
}
private static SqlDataRecord FillRecord(Int32 pk, SqlDataRecord record)
{
Int32 age = SlowRandom(16, 99);
string sourceString = "Age: " + age.ToString();
DateTime sourceDate = DateTime.UtcNow;
var data = /*salt + */sourceString;
string key = "Top Secret Key";
var encData = AES.EncryptBytes(data, key);
//var encDataBytes = Encoding.Unicode.GetBytes(encData);
var decData = AES.DecryptBytes(encData, key);
var sha = new SHA256Managed();
byte[] dataSHA256 = sha.ComputeHash(encData/*Bytes*/);
sha.Dispose();
// конвертирую хеш из byte[16] в строку шестнадцатиричного формата
// (вида «3C842B246BC74D28E59CCD92AF46F5DA»)
// это опциональный этап, если вам хеш нужен в строковом виде
// string sha512hex = BitConverter.ToString(dataSHA512).Replace("-", string.Empty);
record.SetInt32(0, pk);
record.SetDateTime(1, sourceDate);
record.SetString(2, sourceString);
record.SetString(3, Convert.ToBase64String(dataSHA256)); // sha256
record.SetString(4, Convert.ToBase64String(encData)); // Encrypted
record.SetString(5, decData); // Decrypted
return record;
}
public static void SendDataTable(DataTable dt)
{
bool[] coerceToString; // Do we need to coerce this column to string?
SqlMetaData[] metaData = ExtractDataTableColumnMetaData(dt, out coerceToString);
SqlDataRecord record = new SqlDataRecord(metaData);
SqlPipe pipe = SqlContext.Pipe;
pipe.SendResultsStart(record);
try
{
foreach (DataRow row in dt.Rows)
{
for (int index = 0; index < record.FieldCount; index++)
{
object value = row[index];
if (null != value && coerceToString[index])
value = value.ToString();
record.SetValue(index, value);
}
pipe.SendResultsRow(record);
}
}
finally
{
pipe.SendResultsEnd();
}
}
public static void ProcedurePatientIdGenerator()
{
using (SqlConnection connection = new SqlConnection(@"context connection=true"))
{
if (SqlContext.IsAvailable)
{
connection.Open();
lock (lockObject)
{
SqlCommand cmd = new SqlCommand("SELECT PatientIdGenerator FROM [dbo].[SystemSettings]", connection);
int patientId = (int)cmd.ExecuteScalar();
patientId++;
cmd = new SqlCommand("UPDATE [dbo].[SystemSettings] SET PatientIdGenerator=@patientId WHERE id=1", connection);
cmd.Parameters.Add(new SqlParameter("@patientId", patientId));
cmd.ExecuteNonQuery();
// Create a record object that represents an individual row, including it's metadata.
SqlDataRecord record = new SqlDataRecord(new SqlMetaData("patientId", SqlDbType.Int));
// Populate the record.
record.SetInt32(0, patientId);
SqlContext.Pipe.Send(record);
}
}
}
}
internal static SqlDataRecord ToSqlDataRecord(this EventEntry record, string instanceName, PayloadFormatting payloadFormatting)
{
var sqlDataRecord = new SqlDataRecord(SqlMetaData);
var payloadValue = payloadFormatting == PayloadFormatting.Json
? EventEntryUtil.JsonSerializePayload(record)
: EventEntryUtil.XmlSerializePayload(record);
sqlDataRecord.SetValue(0, instanceName ?? string.Empty);
sqlDataRecord.SetValue(1, record.ProviderId);
sqlDataRecord.SetValue(2, record.Schema.ProviderName ?? string.Empty);
sqlDataRecord.SetValue(3, record.EventId);
sqlDataRecord.SetValue(4, (long)record.Schema.Keywords);
sqlDataRecord.SetValue(5, (int)record.Schema.Level);
sqlDataRecord.SetValue(6, (int)record.Schema.Opcode);
sqlDataRecord.SetValue(7, (int)record.Schema.Task);
sqlDataRecord.SetValue(8, record.Timestamp);
sqlDataRecord.SetValue(9, record.Schema.Version);
sqlDataRecord.SetValue(10, (object)record.FormattedMessage ?? DBNull.Value);
sqlDataRecord.SetValue(11, (object)payloadValue ?? DBNull.Value);
sqlDataRecord.SetValue(12, record.ActivityId);
sqlDataRecord.SetValue(13, record.RelatedActivityId);
sqlDataRecord.SetValue(14, record.ProcessId);
sqlDataRecord.SetValue(15, record.ThreadId);
return sqlDataRecord;
}
private static SqlDataRecord CreateStringIdRecord(string id)
{
var record = new SqlDataRecord(new SqlMetaData("Id", SqlDbType.NVarChar, 16));
record.SetSqlString(0, id);
return record;
}
private static SqlDataRecord CreateBigIdentityIdRecord(long id)
{
var record = new SqlDataRecord(new SqlMetaData("Id", SqlDbType.BigInt));
record.SetInt64(0, id);
return record;
}
internal override DataTable GetSkylineTable(IEnumerable<object[]> database, DataTable dataTableTemplate, SqlDataRecord dataRecordTemplate, string preferenceOperators)
{
Strategy = getSPSkyline();
DataTable dt = Strategy.GetSkylineTable(database, dataTableTemplate, dataRecordTemplate, preferenceOperators, RecordAmountLimit, true, SortType, AdditionParameters);
TimeMilliseconds = Strategy.TimeInMs;
NumberOfComparisons = Strategy.NumberOfOperations;
NumberOfMoves = Strategy.NumberOfMoves;
return dt;
}
private static SqlDataRecord createRecordPopulatedWithData(SqlDataReader dataReader, SqlMetaData[] meta)
{
SqlDataRecord rec = new SqlDataRecord(meta);
object[] recordData = new object[dataReader.FieldCount];
dataReader.GetSqlValues(recordData);
rec.SetValues(recordData);
return rec;
}
public static void IR_SM_AvailableObjective()
{
using (SqlConnection con = new SqlConnection("context connection=true"))
{
SqlPipe pipe = SqlContext.Pipe;
List<SqlCommand> commands = new List<SqlCommand>();
commands.Add(new SqlCommand("SELECT distinct [BUDGETTYPECODE] as ObjectiveType, [YEAR] as YearT, BRANDCODE as BrandCode FROM [SALESBUDGET] inner join SAPRODUCTS on SAPRODUCTS.saproductcode = salesbudget.saproductcode order by BRANDCODE"));
commands.Add(new SqlCommand("SELECT distinct [type] as ObjectiveType, [year] as YearT, [brandcode] as BrandCode FROM [IR_Brand_Budget] order by brandcode"));
SqlDataRecord record = new SqlDataRecord(new SqlMetaData("ObjectiveType", SqlDbType.NVarChar, 50),
new SqlMetaData("YearT", SqlDbType.Int),
new SqlMetaData("BrandCode", SqlDbType.NVarChar, 50),
new SqlMetaData("TotalProvince", SqlDbType.NVarChar, 50));
pipe.SendResultsStart(record);
bool isTotal = true;
foreach (SqlCommand cmd in commands)
{
try
{
cmd.Connection = con;
con.Open();
SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
string objectiveType = Convert.ToString(dr["objectivetype"]);
int year = Convert.ToInt32(dr["yeart"]);
string brandCode = Convert.ToString(dr["brandcode"]);
string totalProvince = (isTotal) ? "T" : "P";
record.SetString(0, objectiveType);
record.SetInt32(1, year);
record.SetString(2, brandCode);
record.SetString(3, totalProvince);
pipe.SendResultsRow(record);
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (con != null)
con.Close();
isTotal = false;
}
}
pipe.SendResultsEnd();
}
}
public static void IR_SM_PriceList_PerType()
{
using (SqlConnection con = new SqlConnection("context connection=true"))
{
SqlPipe pipe = SqlContext.Pipe;
List<SqlCommand> commands = new List<SqlCommand>();
try
{
commands.Add(new SqlCommand("SELECT DISTINCT IR_PriceList.PRICE, IR_PriceList.YEAR AS YearT, IR_PriceList.MONTH AS MonthT, IR_PriceList.SAPRODUCTCODE, IR_PriceList.PRICETYPE FROM IR_PriceList"));
SqlDataRecord record = new SqlDataRecord(new SqlMetaData("PRICE", SqlDbType.Float),
new SqlMetaData("MonthT", SqlDbType.Int),
new SqlMetaData("YearT", SqlDbType.Int),
new SqlMetaData("SAPRODUCTCODE", SqlDbType.NVarChar, 20),
new SqlMetaData("PRICETYPE", SqlDbType.NVarChar, 20));
pipe.SendResultsStart(record);
foreach (SqlCommand cmd in commands)
{
try
{
cmd.Connection = con;
con.Open();
SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
double price = Convert.ToDouble(dr["PRICE"]);
int month = Convert.ToInt32(dr["montht"]);
int year = Convert.ToInt32(dr["yeart"]);
string saproductcode = Convert.ToString(dr["SAPRODUCTCODE"]);
string thePriceType = Convert.ToString(dr["PRICETYPE"]);
record.SetDouble(0, price);
record.SetInt32(1, month);
record.SetInt32(2, year);
record.SetString(3, saproductcode);
record.SetString(4, thePriceType);
pipe.SendResultsRow(record);
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (con != null)
con.Close();
}
}
pipe.SendResultsEnd();
}
catch (Exception ex)
{
throw ex;
}
}
}
private static void BindFile(FileInfo _file, SqlDataRecord record)
{
record.SetSqlDateTime(0, _file.Exists ? _file.CreationTime : SqlDateTime.Null);
record.SetSqlDateTime(1, _file.Exists ? _file.LastAccessTime : SqlDateTime.Null);
record.SetSqlDateTime(2, _file.Exists ? _file.LastWriteTime : SqlDateTime.Null);
record.SetSqlBoolean(3, _file.Exists);
record.SetString(4, _file.Name);
record.SetString(5, _file.DirectoryName);
record.SetString(6, _file.Extension);
record.SetSqlInt64(7, _file.Exists ? _file.Length : SqlInt64.Null);
}
public static void GetConnectedPublnSets()
{
using (var connection = new SqlConnection("context connection=true"))
{
connection.Open();
using (SqlCommand command = connection.CreateCommand())
{
SqlDataRecord record = new SqlDataRecord(new SqlMetaData[] {
new SqlMetaData("cluster", SqlDbType.Int),
new SqlMetaData("new_id", SqlDbType.Int)
});
SqlContext.Pipe.SendResultsStart(record);
List<int> publnUT = new List<int>();
List<int> pubMinPairIndex = new List<int>();
List<int> pubMaxPairIndex = new List<int>();
List<int> pairPub2Index = new List<int>();
command.CommandText = string.Format("select new_id, min_pair_index, max_pair_index from tmp_publns4 order by pub_index");
using (SqlDataReader reader = command.ExecuteReader())
while (reader.Read())
{
publnUT.Add(reader.GetInt32(0));
pubMinPairIndex.Add(reader.GetInt32(1));
pubMaxPairIndex.Add(reader.GetInt32(2));
}
command.CommandText = string.Format("select publn2_index from tmp_publn_pairs3 order by pair_index");
using (SqlDataReader reader = command.ExecuteReader())
while (reader.Read())
pairPub2Index.Add(reader.GetInt32(0));
ConnectedPubSetSearcher connectedPubSetSearcher = new ConnectedPubSetSearcher(pubMinPairIndex, pubMaxPairIndex, pairPub2Index);
List<List<int>> connectedPubSets = connectedPubSetSearcher.getConnectedPubSets();
for (int i = 0; i < connectedPubSets.Count; i++)
{
record.SetValue(0, i);
for (int j = 0; j < connectedPubSets[i].Count; j++)
{
record.SetValue(1, publnUT[connectedPubSets[i][j]]);
SqlContext.Pipe.SendResultsRow(record);
}
}
SqlContext.Pipe.SendResultsEnd();
}
}
}
public static void GerarEventoAuditoria(this DbContext context, int codigoTipoEventoAuditoria, Func<int> idUsuarioFunc, params ParametroEvento[] parametrosEvento)
{
string siglaSistemaPermisys = ConfigurationManager.AppSettings["Permisys.SiglaSistema"];
string siglaModuloPermisys = ConfigurationManager.AppSettings["Permisys.SiglaModulo"];
if (string.IsNullOrWhiteSpace("Permisys.SiglaSistema") || string.IsNullOrWhiteSpace("Permisys.SiglaModulo")) {
throw new Exception("As configurações \"Permisys.SiglaSistema\" e \"Permisys.SiglaModulo\" são obrigatórias.");
}
if (idUsuarioFunc == null) {
throw new Exception("A função de obtenção do ID do usuário é obrigatória.");
}
int idUsuarioPermisys = idUsuarioFunc();
List<SqlDataRecord> parametros = null;
if (parametrosEvento != null && parametrosEvento.Count() > 0) {
parametros = new List<SqlDataRecord>();
SqlMetaData[] rowMetadata = new SqlMetaData[] {
new SqlMetaData("ORDEM", SqlDbType.Int),
new SqlMetaData("NOME", SqlDbType.VarChar, 20),
new SqlMetaData("VALOR", SqlDbType.VarChar, 100)
};
foreach (var parametro in parametrosEvento) {
if (string.IsNullOrWhiteSpace(parametro.Nome) || string.IsNullOrWhiteSpace(parametro.Valor)) {
throw new Exception("O \"Nome\" e \"Valor\" são obrigatórios para todos os parâmetros.");
}
SqlDataRecord row = new SqlDataRecord(rowMetadata);
row.SetInt32(0, parametro.Ordem);
row.SetString(1, parametro.Nome);
row.SetString(2, parametro.Valor);
parametros.Add(row);
}
}
context.Database.ExecuteSqlCommand("LOGSYS.SP_GERAR_EVENTO_AUDITORIA @SIGLA_SISTEMA_PERMISYS, @SIGLA_MODULO_PERMISYS, @ID_USUARIO_PERMISYS, @CODIGO_TIPO_EVENTO_AUDITORIA, @PARAMETROS_EVENTO",
new object[] {
new SqlParameter("SIGLA_SISTEMA_PERMISYS", SqlDbType.VarChar, 30) { Value = siglaSistemaPermisys },
new SqlParameter("SIGLA_MODULO_PERMISYS", SqlDbType.VarChar, 30) { Value = siglaModuloPermisys },
new SqlParameter("ID_USUARIO_PERMISYS", SqlDbType.Int) { Value = idUsuarioPermisys },
new SqlParameter("CODIGO_TIPO_EVENTO_AUDITORIA", SqlDbType.Int) { Value = codigoTipoEventoAuditoria },
new SqlParameter("PARAMETROS_EVENTO", SqlDbType.Structured) { TypeName = "LOGSYS.LOGSYS_LISTA_PARAMETROS", Value = parametros }
}
);
}
private static SqlDataRecord buildRecord(SqlMetaData[] metadata,EventLogEntry entry)
{
SqlDataRecord record = new SqlDataRecord(metadata);
record.SetSqlInt32(0, entry.Index);
record.SetSqlInt64(1, entry.InstanceId);
record.SetSqlDateTime(2, entry.TimeWritten);
record.SetSqlString(3, entry.MachineName);
record.SetSqlString(4, entry.Source);
record.SetSqlString(5, entry.UserName);
record.SetSqlString(6, entry.Message);
return record;
}
public SqlDataRecord SendStart(DataTable dt)
{
if (SqlContext.IsAvailable && SqlContext.Pipe != null)
{
IEnumerable<SqlMetaData> metaData =
dt.Columns.Cast<DataColumn>()
.Select(c => new SqlMetaData(c.ColumnName, SqlDbType.VarChar, SqlMetaData.Max));
var dataRecord = new SqlDataRecord(metaData.ToArray());
SqlContext.Pipe.SendResultsStart(dataRecord);
return dataRecord;
}
return null;
}
private void AddToWindow(object[] newTuple, string[] operators, ArrayList resultCollection, ArrayList resultstringCollection, SqlDataRecord record, SqlBoolean isFrameworkMode, int level, DataTable dtResult)
{
//Erste Spalte ist die ID
long?[] recordInt = new long?[operators.GetUpperBound(0) + 1];
string[] recordstring = new string[operators.GetUpperBound(0) + 1];
DataRow row = dtResult.NewRow();
for (int iCol = 0; iCol <= newTuple.GetUpperBound(0); iCol++)
{
//Only the real columns (skyline columns are not output fields)
if (iCol <= operators.GetUpperBound(0))
{
//LOW und HIGH Spalte in record abfüllen
if (operators[iCol].Equals("LOW"))
{
if (newTuple[iCol] == DBNull.Value)
recordInt[iCol] = null;
else
recordInt[iCol] = (long)newTuple[iCol];
//Check if long value is incomparable
if (iCol + 1 <= recordInt.GetUpperBound(0) && operators[iCol + 1].Equals("INCOMPARABLE"))
{
//Incomparable field is always the next one
recordstring[iCol] = (string)newTuple[iCol + 1];
}
}
}
else
{
row[iCol - (operators.GetUpperBound(0) + 1)] = newTuple[iCol];
record.SetValue(iCol - (operators.GetUpperBound(0) + 1), newTuple[iCol]);
}
}
row[record.FieldCount - 1] = level;
record.SetValue(record.FieldCount - 1, level);
if (isFrameworkMode == true)
{
dtResult.Rows.Add(row);
}
else
{
SqlContext.Pipe.SendResultsRow(record);
}
resultCollection.Add(recordInt);
resultstringCollection.Add(recordstring);
}
public static void AccountantPagesCounterIncrementor(string columnName)
{
using (SqlConnection connection = new SqlConnection(@"context connection=true"))
{
connection.Open();
string txtCommand = string.Format(@"UPDATE [dbo].[AccountantPagesCounters] SET {0}=({0} + 1) WHERE Id=1;"
+ "SELECT {0} FROM [dbo].[AccountantPagesCounters] WHERE Id=1;", columnName);
SqlCommand cmd = new SqlCommand(txtCommand, connection);
int sheetNumber = (int)cmd.ExecuteScalar();
SqlMetaData sqlMetaData = new SqlMetaData("AccountantPageNumber", SqlDbType.Int);
SqlDataRecord record = new SqlDataRecord(sqlMetaData);
record.SetInt32(0, sheetNumber);
SqlContext.Pipe.Send(record);
}
}
public static IEnumerable<SqlDataRecord> TSqlDataRecord(List<Menu> ListaMenu)
{
List<SqlDataRecord> listaSqlDataRecord = new List<SqlDataRecord>();
foreach (Menu oMenu in ListaMenu)
{
SqlDataRecord oSqlDataRecord = new SqlDataRecord(
new SqlMetaData[]{ new SqlMetaData("nMenuId", SqlDbType.Int),
new SqlMetaData("nValor", SqlDbType.Bit)
});
oSqlDataRecord.SetInt32(0, oMenu.nMenuId);
oSqlDataRecord.SetBoolean(1, oMenu.bEstado);
listaSqlDataRecord.Add(oSqlDataRecord);
}
return listaSqlDataRecord;
}
public static IEnumerable<SqlDataRecord> TSqlDataRecord(List<Permiso> ListaPermiso)
{
List<SqlDataRecord> listaSqlDataRecord = new List<SqlDataRecord>();
foreach (Permiso oPermiso in ListaPermiso)
{
SqlDataRecord oSqlDataRecord = new SqlDataRecord(
new SqlMetaData[]{ new SqlMetaData("nModId", SqlDbType.Int),
new SqlMetaData("nPermId", SqlDbType.Int),
new SqlMetaData("nValor", SqlDbType.Bit)
});
oSqlDataRecord.SetInt32(0, oPermiso.nModId);
oSqlDataRecord.SetInt32(1, oPermiso.nPermId);
oSqlDataRecord.SetBoolean(2, oPermiso.bEstado);
listaSqlDataRecord.Add(oSqlDataRecord);
}
return listaSqlDataRecord;
}
public void SendRow(SqlDataRecord dataRecord, object[] items)
{
for (int i = 0; i < items.Length; i++)
{
string value = items[i].ToStringSafe();
if (string.IsNullOrEmpty(value))
{
dataRecord.SetDBNull(i);
}
else
{
dataRecord.SetString(i, value);
}
}
if (SqlContext.IsAvailable && SqlContext.Pipe != null)
{
// Send the row back to the client.
SqlContext.Pipe.SendResultsRow(dataRecord);
}
}
public void Update(IList<TreeViewNode> treeViewNodes)
{
var sqlConnection = new SqlConnection(ConnectionString);
var sqlCommand = new SqlCommand("dbo.UpdateTreeViewData", sqlConnection)
{
CommandType = CommandType.StoredProcedure,
};
sqlCommand.Parameters.Add("@p_TreeViewData", SqlDbType.Structured);
var list = new List<SqlDataRecord>();
foreach (var treeViewNode in treeViewNodes)
{
var sqlDataRecord = new SqlDataRecord(
new SqlMetaData("Id", SqlDbType.Int),
new SqlMetaData("ParentId", SqlDbType.Int),
new SqlMetaData("NodeName", SqlDbType.NVarChar, 50),
new SqlMetaData("IsSelected", SqlDbType.Bit));
sqlDataRecord.SetValue(0, treeViewNode.Id);
sqlDataRecord.SetValue(1, treeViewNode.ParentId);
sqlDataRecord.SetString(2, treeViewNode.NodeName);
sqlDataRecord.SetValue(3, treeViewNode.IsSelected);
list.Add(sqlDataRecord);
}
sqlCommand.Parameters["@p_TreeViewData"].Value = list;
try
{
sqlConnection.Open();
sqlCommand.ExecuteNonQuery();
}
finally
{
sqlConnection.Close();
}
}
public void DeleteSurveyTokensByIdMultiple(IEnumerable<int> ids)
{
SqlMetaData[] tab = { new SqlMetaData("value", SqlDbType.Int) };
List<SqlDataRecord> idList =
ids.Select(x => { var y = new SqlDataRecord(tab); y.SetInt32(0, x); return y; }).ToList<SqlDataRecord>();
SqlParameter p = new SqlParameter("@tblTokenIdList", SqlDbType.Structured);
p.Direction = ParameterDirection.Input;
p.TypeName = "dbo.IntTableType";
p.Value = idList;
SqlCommand cmd = new SqlCommand();
using (SqlConnection conn = new SqlConnection(DbConnection.NewDbConnectionString))
{
conn.Open();
cmd.Connection = conn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "vts_spSurveyTokenDeleteMultiple";
cmd.Parameters.Add(p);
cmd.ExecuteNonQuery();
}
}
public static IEnumerable<SqlDataRecord> TSqlDataRecord(List<NotaEntProd> listaNotaEntProd)
{
List<SqlDataRecord> listaSqlDataRecord = new List<SqlDataRecord>();
foreach (NotaEntProd oNotaEntProd in listaNotaEntProd)
{
SqlDataRecord oSqlDataRecord = new SqlDataRecord(
new SqlMetaData[]{ new SqlMetaData("nProdId", SqlDbType.Int),
new SqlMetaData("nDetCantidad", SqlDbType.Decimal,12,3),
new SqlMetaData("nDetProdPrecioUnit", SqlDbType.Money),
new SqlMetaData("nDetImporte", SqlDbType.Money)
});
oSqlDataRecord.SetInt32(0, oNotaEntProd.oProd.nProdId);
oSqlDataRecord.SetSqlDecimal(1, oNotaEntProd.nDetCantidad);
oSqlDataRecord.SetSqlMoney(2, oNotaEntProd.nProdPrecioUnit);
oSqlDataRecord.SetSqlMoney(3, oNotaEntProd.nDetImporte);
listaSqlDataRecord.Add(oSqlDataRecord);
}
return listaSqlDataRecord;
}
/// <summary>Send a DataTable to a SqlContext.</summary>
/// <exception cref="Exception">Throw an exception if the DataTable is null.</exception>
/// <param name="dt">The DataTable to send to the SqlContext.</param>
internal static void SendDataTable(DataTable dt)
{
if (dt == null)
{
throw new Exception(ExceptionMessage.Unexpected_NullResultSet);
}
bool[] useToString;
var metaData = ExtractDataTableColumnMetaData(dt, out useToString);
var record = new SqlDataRecord(metaData);
var pipe = SqlContext.Pipe;
pipe.SendResultsStart(record);
try
{
foreach (DataRow row in dt.Rows)
{
for (var index = 0; index < record.FieldCount; index++)
{
var value = row[index];
if (value != null && useToString[index])
{
value = value.ToString();
}
record.SetValue(index, value);
}
pipe.SendResultsRow(record);
}
}
finally
{
pipe.SendResultsEnd();
}
}
public static void Shop_CalculateRefund(string StoreName, string APIKey, string Password, long OrderID, string JsonString)
{
ShopifyClient sp = new ShopifyClient(StoreName, APIKey, Password);
SqlPipe p = SqlContext.Pipe;
// Create a new record with the column metadata. The constructor is
// able to accept a variable number of parameters.
SqlDataRecord record = new SqlDataRecord(
new SqlMetaData[] { new SqlMetaData("ShippingAmount", SqlDbType.NVarChar,18),
new SqlMetaData("ShippingTax", SqlDbType.NVarChar,18),
new SqlMetaData("MaximumRefundable", SqlDbType.NVarChar,18),
new SqlMetaData("RefundLineItems", SqlDbType.Int,4),
new SqlMetaData("Transactions", SqlDbType.Int,4)}
);
Refund r = sp.CalculateRefund(OrderID, JsonString);
// Mark the begining of the result-set.
SqlContext.Pipe.SendResultsStart(record);
// Set the record fields.
record.SetString(0,r.shipping.amount);
record.SetString(1, r.shipping.tax);
record.SetString(2, r.shipping.maximum_refundable);
record.SetInt32(3, r.refund_line_items.Count);
record.SetInt32(4, r.transactions.Count);
//record.SetInt32(1, 42);
//record.SetDateTime(2, DateTime.Now);
// Send the row back to the client.
SqlContext.Pipe.SendResultsRow(record);
// Mark the end of the result-set.
SqlContext.Pipe.SendResultsEnd();
// Send the record to the calling program.
SqlContext.Pipe.Send(record);
}
public void SendResultsRow(SqlDataRecord record)
{
throw new NotImplementedException();
}
