IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("PageZoneId", SqlDbType.BigInt),
new SqlMetaData("MasterPageId", SqlDbType.BigInt),
new SqlMetaData("MasterPageZoneId", SqlDbType.BigInt),
new SqlMetaData("PageId", SqlDbType.BigInt)
);
foreach (PageZone pageZone in this)
{
if (pageZone.PageZoneId != 0)
{
sdr.SetInt64(0, pageZone.PageZoneId);
}
else
{
sdr.SetDBNull(0);
}
sdr.SetInt64(1, pageZone.MasterPageId);
sdr.SetInt64(2, pageZone.MasterPageZoneId);
if (pageZone.PageId != 0)
{
sdr.SetInt64(3, pageZone.PageId);
}
else
{
sdr.SetDBNull(3);
}
yield return(sdr);
}
}
public void AddParameters(IDbCommand command, SqlMapper.Identity identity)
{
var sqlCommand = (SqlCommand)command;
sqlCommand.CommandType = CommandType.StoredProcedure;
var items = new List <SqlDataRecord>();
foreach (var param in _transfers)
{
var rec = new SqlDataRecord(_transferIdMetaData, _senderAccountIdMetaData, _receiverAccountIdMetaData, _requiredPaymentId, _commitmentId, _amount, _type, _collectionPeriodName);
rec.SetInt64(0, param.TransferId);
rec.SetInt64(1, param.SenderAccountId);
rec.SetInt64(2, param.ReceiverAccountId);
rec.SetGuid(3, param.RequiredPaymentId);
rec.SetInt64(4, param.CommitmentId);
rec.SetDecimal(5, param.Amount);
rec.SetString(6, param.Type.ToString());
rec.SetString(7, param.CollectionPeriodName);
items.Add(rec);
}
var p = sqlCommand.Parameters.Add("@transfers", SqlDbType.Structured);
p.Direction = ParameterDirection.Input;
p.TypeName = "[Data_Load].[TransferEntity]";
p.Value = items;
}
private static IEnumerable <SqlDataRecord> BindDishRows(IEnumerable <DishEntity> dishesToUpdate)
{
foreach (var dish in dishesToUpdate)
{
SqlDataRecord record = new SqlDataRecord(typ_DishTable);
record.SetInt64(0, dish.DishId);
record.SetInt64(1, dish.ProviderId);
record.SetInt32(2, (int)dish.DishType);
record.SetString(3, dish.DishName);
record.SetString(4, dish.Description);
record.SetString(5, dish.Ingredients);
record.SetDecimal(6, dish.Price);
record.SetInt32(7, dish.WaitingTimeInMins);
if (!dish.ThumbNailPictureKey.HasValue)
{
record.SetDBNull(8);
}
else
{
record.SetGuid(8, dish.ThumbNailPictureKey.Value);
}
record.SetBoolean(9, dish.Available);
yield return(record);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("NavBarTabId", SqlDbType.BigInt),
new SqlMetaData("Name", SqlDbType.NVarChar, 50),
new SqlMetaData("SortOrder", SqlDbType.Int),
new SqlMetaData("PageId", SqlDbType.BigInt)
);
foreach (NavBarTab navBarTab in this)
{
if (navBarTab.NavBarTabId != 0)
{
sdr.SetInt64(0, navBarTab.NavBarTabId);
}
else
{
sdr.SetDBNull(0);
}
sdr.SetString(1, navBarTab.Name);
sdr.SetInt32(2, navBarTab.SortOrder);
sdr.SetInt64(3, navBarTab.PageId);
yield return(sdr);
}
}
/// <summary>
/// Retrieves master page zone element records.
/// </summary>
/// <returns>Enumerable SQL data records.</returns>
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("MasterPageZoneId", SqlDbType.BigInt),
new SqlMetaData("MasterPageZoneElementId", SqlDbType.BigInt),
new SqlMetaData("MasterPageZoneSortOrder", SqlDbType.Int),
new SqlMetaData("SortOrder", SqlDbType.Int),
new SqlMetaData("ElementId", SqlDbType.BigInt),
new SqlMetaData("BeginRender", SqlDbType.NVarChar, -1),
new SqlMetaData("EndRender", SqlDbType.NVarChar, -1)
);
foreach (MasterPageZoneElement masterPageZoneElement in this)
{
if (masterPageZoneElement.MasterPageZoneId != 0)
{
sdr.SetInt64(0, masterPageZoneElement.MasterPageZoneId);
}
else
{
sdr.SetDBNull(0);
}
if (masterPageZoneElement.MasterPageZoneElementId != 0)
{
sdr.SetInt64(1, masterPageZoneElement.MasterPageZoneElementId);
}
else
{
sdr.SetDBNull(1);
}
sdr.SetInt32(2, masterPageZoneElement.MasterPageZoneSortOrder);
sdr.SetInt32(3, masterPageZoneElement.SortOrder);
sdr.SetInt64(4, masterPageZoneElement.ElementId);
if (masterPageZoneElement.BeginRender != null)
{
sdr.SetString(5, masterPageZoneElement.BeginRender);
}
else
{
sdr.SetDBNull(5);
}
if (masterPageZoneElement.EndRender != null)
{
sdr.SetString(6, masterPageZoneElement.EndRender);
}
else
{
sdr.SetDBNull(6);
}
yield return(sdr);
}
}
private static IEnumerable <SqlDataRecord> BindOrderItemRows(IEnumerable <OrderItemEntity> orderItemsToUpdate)
{
foreach (var orderItem in orderItemsToUpdate)
{
SqlDataRecord record = new SqlDataRecord(typ_OrderItemTable);
record.SetInt64(0, orderItem.OrderId);
record.SetInt64(1, orderItem.DishId);
record.SetInt32(2, orderItem.Quantity);
record.SetInt32(3, (int)orderItem.ItemStatus);
yield return(record);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("FormFieldId", SqlDbType.BigInt),
new SqlMetaData("SortOrder", SqlDbType.Int),
new SqlMetaData("FormFieldType", SqlDbType.Int),
new SqlMetaData("Label", SqlDbType.NVarChar, 100),
new SqlMetaData("Required", SqlDbType.Bit)
);
foreach (FormElementField field in this)
{
if (field.FormFieldId != 0)
{
sdr.SetInt64(0, field.FormFieldId);
}
else
{
sdr.SetDBNull(0);
}
sdr.SetInt32(1, field.SortOrder);
sdr.SetInt32(2, (int)field.FieldType);
sdr.SetString(3, field.Label);
sdr.SetBoolean(4, field.Required);
yield return(sdr);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("TestimonialCommentId", SqlDbType.BigInt),
new SqlMetaData("SortOrder", SqlDbType.Int),
new SqlMetaData("Comment", SqlDbType.NVarChar, -1),
new SqlMetaData("Author", SqlDbType.NVarChar, 100),
new SqlMetaData("AuthorTitle", SqlDbType.NVarChar, 100),
new SqlMetaData("CommentDate", SqlDbType.NVarChar, 30)
);
foreach (TestimonialComment comment in this)
{
if (comment.TestimonialCommentId != 0)
{
sdr.SetInt64(0, comment.TestimonialCommentId);
}
else
{
sdr.SetDBNull(0);
}
sdr.SetInt32(1, comment.SortOrder);
sdr.SetString(2, comment.Comment);
sdr.SetString(3, comment.Author);
sdr.SetString(4, comment.AuthorTitle);
sdr.SetString(5, comment.CommentDate);
yield return(sdr);
}
}
public static void CallQuoteService(string ticker, string quoteType, DateTime?date)
{
SqlDataRecord record = new SqlDataRecord(
new SqlMetaData("Ticker", SqlDbType.VarChar, 20),
new SqlMetaData("Date", SqlDbType.DateTime, -1),
new SqlMetaData("Open", SqlDbType.Decimal, -1),
new SqlMetaData("Close", SqlDbType.Decimal, -1),
new SqlMetaData("High", SqlDbType.Decimal, -1),
new SqlMetaData("Low", SqlDbType.Decimal, -1),
new SqlMetaData("Wap", SqlDbType.Decimal, -1),
new SqlMetaData("Volume", SqlDbType.BigInt, -1),
new SqlMetaData("ErrorMessage", SqlDbType.VarChar, -1)
);
try
{
SqlPipe sqlPip = SqlContext.Pipe;
var result = ClientUtilities.GetQuote(ticker, quoteType, date.Value);
record.SetString(0, result.Ticker);
record.SetDateTime(1, result.Date);
record.SetDecimal(2, (decimal)result.Open);
record.SetDecimal(3, (decimal)result.Close);
record.SetDecimal(4, (decimal)result.High);
record.SetDecimal(5, (decimal)result.Low);
record.SetDecimal(6, (decimal)result.Wap);
record.SetInt64(7, result.Volume);
record.SetString(8, result.ErrorMessage);
SqlContext.Pipe.Send(record);
}
catch (Exception ex)
{
record.SetString(8, ex.Message);
SqlContext.Pipe.Send(record);
}
}
public override ISessionFactory CreateSessionFactory()
{
return(SessionFactory.With(config =>
config
.WithConnectionString(ConnectionString)
.WithProviderFactory(ProviderFactory)
.WithTableParameterHandler <long>((value, parameter) =>
{
var sqlParameter = (SqlParameter)parameter;
SqlMetaData[] tvpDefinition = { new SqlMetaData("id", SqlDbType.BigInt) };
sqlParameter.Value = value.Select(i =>
{
var sqlDataRecord = new SqlDataRecord(tvpDefinition);
sqlDataRecord.SetInt64(0, i);
return sqlDataRecord;
}).ToList();
sqlParameter.SqlDbType = SqlDbType.Structured;
sqlParameter.TypeName = "t_BigIntArray";
})
.WithParameterHandler <Person>((value, parameter) =>
{
parameter.Value = value.Name;
parameter.DbType = DbType.String;
})));
}
public static SqlDataRecord CreateDataRecordInt64(int ordinal, long value, params SqlMetaData[] metaData)
{
var record = new SqlDataRecord(metaData);
record.SetInt64(ordinal, value);
return(record);
}
static SqlDataRecord PopulateMessageIdRecord(TaskMessage message, SqlDataRecord record)
{
// IMPORTANT: The order of these columns must always match the order of the SQL type
record.SetString(0, message.OrchestrationInstance.InstanceId);
record.SetInt64(1, message.SequenceNumber);
return(record);
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("AlbumPhotoId", SqlDbType.BigInt),
new SqlMetaData("ImageTenantId", SqlDbType.BigInt),
new SqlMetaData("ThumbnailImageUploadId", SqlDbType.BigInt),
new SqlMetaData("PreviewImageUploadId", SqlDbType.BigInt),
new SqlMetaData("ImageUploadId", SqlDbType.BigInt),
new SqlMetaData("Name", SqlDbType.NVarChar, 256),
new SqlMetaData("Description", SqlDbType.NVarChar, -1),
new SqlMetaData("SortOrder", SqlDbType.Int)
);
foreach (AlbumPhoto albumPhoto in this)
{
if (albumPhoto.AlbumPhotoId != 0)
{
sdr.SetInt64(0, albumPhoto.AlbumPhotoId);
}
else
{
sdr.SetDBNull(0);
}
sdr.SetInt64(1, albumPhoto.ImageTenantId);
sdr.SetInt64(2, albumPhoto.ThumbnailImageUploadId);
sdr.SetInt64(3, albumPhoto.PreviewImageUploadId);
sdr.SetInt64(4, albumPhoto.ImageUploadId);
if (albumPhoto.Name != null)
{
sdr.SetString(5, albumPhoto.Name);
}
else
{
sdr.SetDBNull(5);
}
if (albumPhoto.Description != null)
{
sdr.SetString(6, albumPhoto.Description);
}
else
{
sdr.SetDBNull(6);
}
sdr.SetInt32(7, albumPhoto.SortOrder);
yield return(sdr);
}
}
private static SqlDataRecord CreateBigIdentityIdRecord(long id)
{
var record = new SqlDataRecord(new SqlMetaData("Id", SqlDbType.BigInt));
record.SetInt64(0, id);
return(record);
}
/// <summary>
/// Sets the int64.
/// </summary>
/// <param name="record">The record.</param>
/// <param name="fieldName">Name of the field.</param>
/// <param name="value">The value.</param>
public static void SetInt64(this SqlDataRecord record, string fieldName, Int64?value)
{
int ordinal = GetOrdinal(record, fieldName);
if (value.HasValue)
{
record.SetInt64(ordinal, value.Value);
}
}
private static IEnumerable <SqlDataRecord> BindProviderRows(IEnumerable <ProviderEntity> providersToUpdate)
{
foreach (var provider in providersToUpdate)
{
SqlDataRecord record = new SqlDataRecord(typ_ProviderTable);
record.SetInt64(0, provider.ProviderId);
record.SetString(1, provider.AddressLine1);
if (string.IsNullOrWhiteSpace(provider.AddressLine2))
{
record.SetDBNull(2);
}
else
{
record.SetString(2, provider.AddressLine2);
}
if (string.IsNullOrWhiteSpace(provider.AddressLine3))
{
record.SetDBNull(3);
}
else
{
record.SetString(3, provider.AddressLine3);
}
record.SetString(4, provider.City);
if (string.IsNullOrWhiteSpace(provider.StateOrProvince))
{
record.SetDBNull(5);
}
else
{
record.SetString(5, provider.StateOrProvince);
}
record.SetString(6, provider.Country);
record.SetString(7, provider.ZipCode);
record.SetInt32(8, (int)provider.ProviderStatus);
if (provider.GeoLatitude.HasValue)
{
record.SetDouble(9, provider.GeoLatitude.Value);
}
else
{
record.SetDBNull(9);
}
if (provider.GeoLongitude.HasValue)
{
record.SetDouble(10, provider.GeoLongitude.Value);
}
else
{
record.SetDBNull(10);
}
yield return(record);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sqlRow = new SqlDataRecord(new SqlMetaData("Id", SqlDbType.BigInt));
for (int i = 0; i < this.Count; i++)
{
sqlRow.SetInt64(0, this[i]);
yield return(sqlRow);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var record = new SqlDataRecord(MetaData);
foreach (var value in this)
{
record.SetInt32(0, value.PermissionGroupId);
record.SetInt64(1, value.Permissions);
yield return(record);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
SqlDataRecord ret = new SqlDataRecord(
new SqlMetaData("item", SqlDbType.BigInt));
foreach (var item in this)
{
ret.SetInt64(0, item);
yield return(ret);
}
}
public static void SetInt64(this SqlDataRecord record, int index, long?value)
{
if (value == null)
{
record.SetDBNull(index);
}
else
{
record.SetInt64(index, value ?? 0);
}
}
internal override void SetDataRecordValue(SqlDataRecord record, int ordinal)
{
if (InputValue == null)
{
record.SetDBNull(ordinal);
}
else
{
record.SetInt64(ordinal, InputValue.Value);
}
}
public override void Set(SqlDataRecord record, int ordinal, long?value)
{
if (value.HasValue)
{
record.SetInt64(ordinal, value.Value);
}
else
{
record.SetDBNull(ordinal);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("PageId", SqlDbType.BigInt)
);
foreach (Page page in this)
{
sdr.SetInt64(0, page.PageId);
yield return(sdr);
}
}
public static SqlDataRecord SetInt64(this SqlDataRecord r, int pos, long?v)
{
if (!v.HasValue)
{
r.SetDBNull(pos);
}
else
{
r.SetInt64(pos, v.Value);
}
return(r);
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
SqlDataRecord ret = new SqlDataRecord(
new SqlMetaData("LEGACY", SqlDbType.BigInt)
);
foreach (tBaseBL data in this)
{
ret.SetInt64(0, data.Legacy);
yield return(ret);
}
}
private static SqlDataRecord CreateVideoDataRecord(YoutubeVideo video)
{
int index = 0;
var dataRecord = new SqlDataRecord(VideoMetaData);
dataRecord.SetString(index++, video.ChannelId);
dataRecord.SetString(index++, video.Id);
dataRecord.SetString(index++, video.Title);
dataRecord.SetInt64(index++, video.Duration.Ticks);
dataRecord.SetDateTimeOffset(index++, video.PublishedAt);
dataRecord.SetString(index++, video.Thumbnail);
return(dataRecord);
}
private static IEnumerable <SqlDataRecord> BindOrderRows(IEnumerable <OrderEntity> ordersToUpdate)
{
foreach (var order in ordersToUpdate)
{
SqlDataRecord record = new SqlDataRecord(typ_OrderTable);
record.SetInt64(0, order.OrderId);
record.SetInt64(1, order.UserId);
record.SetDateTime(2, order.OrderDate);
record.SetDecimal(3, order.SubTotal);
if (order.Tax.HasValue)
{
record.SetDecimal(4, order.Tax.Value);
}
else
{
record.SetDBNull(4);
}
if (order.OtherCharges.HasValue)
{
record.SetDecimal(5, order.OtherCharges.Value);
}
else
{
record.SetDBNull(5);
}
if (!string.IsNullOrWhiteSpace(order.Notes))
{
record.SetString(6, order.Notes);
}
else
{
record.SetDBNull(6);
}
record.SetInt32(7, (int)order.Status);
yield return(record);
}
}
public override void Set(SqlDataRecord record, int ordinal, long?value)
{
EnsureArg.IsNotNull(record, nameof(record));
if (value.HasValue)
{
record.SetInt64(ordinal, value.Value);
}
else
{
record.SetDBNull(ordinal);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sqlRow = new SqlDataRecord(
new SqlMetaData("FeedItemId", SqlDbType.BigInt),
new SqlMetaData("Title", SqlDbType.NVarChar, 300));
for (int i = 0; i < this.Count; i++)
{
sqlRow.SetInt64(0, this[i].FeedItemId);
sqlRow.SetString(1, this[i].Title ?? string.Empty);
yield return(sqlRow);
}
}
private static void FillUsersWithRoles(IList <UserItemViewModel> users, IDbTransaction transaction)
{
if (!users.Any())
{
return;
}
using (var command = transaction.Connection.CreateCommand())
{
command.Transaction = transaction;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "GetUsersRoles";
var userIdsValue = new List <SqlDataRecord>();
foreach (var user in users)
{
var campaignIdValue = new SqlDataRecord(new SqlMetaData("N", SqlDbType.BigInt));
campaignIdValue.SetInt64(0, Convert.ToInt64(user.UserId));
userIdsValue.Add(campaignIdValue);
}
var userIdsParameter = new SqlParameter("@UserIds", SqlDbType.Structured)
{
TypeName = "INTEGER_LIST_TABLE_TYPE",
Value = userIdsValue
};
command.Parameters.Add(userIdsParameter);
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var userId = (int)reader["UserId"];
var user = users.First(u => u.UserId == userId);
var role = (string)reader["RoleName"];
if (string.IsNullOrEmpty(user.Roles))
{
user.Roles = role;
}
else
{
user.Roles += ", " + role;
}
}
}
}
}
