private void InternalLog(Guid bulkEmailId, DateTime startDate, string eventName, Exception exception,
string messageTemplate, Guid errorResult, Guid userId, params object[] parameters)
{
try {
var message = string.Format(messageTemplate, parameters);
var insert = new Insert(_userConnection).Into("BulkEmailEventLog")
.Set("Name", Column.Parameter(eventName))
.Set("StartDate", Column.Parameter(startDate))
.Set("BulkEmailId", Column.Parameter(bulkEmailId))
.Set("ResultId", Column.Parameter(errorResult))
.Set("Description", Column.Parameter(message));
if (exception != null)
{
string exceptionDetails = GetExceptionDetails(exception);
insert.Set("DetailedResult", Column.Parameter(exceptionDetails));
}
if (userId != Guid.Empty)
{
insert.Set("CreatedById", Column.Parameter(userId));
}
insert.Execute();
} catch (Exception e) {
MailingUtilities.Log.ErrorFormat("Exception while writing log. Msg template: {0}", e, messageTemplate);
}
}
private bool InsertInRandomNonFilledBreak(TaskScore taskData)
{
List <BreakSchedule> breaksWithEnoughSpace = Solution.AdvertisementsScheduledOnBreaks.Values.Where
(
b => b.BreakData.SpanUnits >= b.UnitFill + taskData.AdConstraints.AdSpanUnits
).ToList();
if (breaksWithEnoughSpace.Count == 0)
{
return(false);
}
int breakNum = Random.Next(breaksWithEnoughSpace.Count);
BreakSchedule schedule = breaksWithEnoughSpace[breakNum];
int position = Random.Next(schedule.Count + 1);
Insert insert = new Insert()
{
TvBreak = schedule.BreakData,
AdvertisementOrder = taskData.AdConstraints,
Position = position,
Instance = Instance,
Solution = Solution,
};
insert.Asses();
insert.Execute();
Reporter.AddEntry(insert.GenerateReportEntry());
return(true);
}
private int AddContactToMandrillSentMessage(IMessageInfo messageInfo, Mandrill.EmailResult emailResult)
{
if (emailResult == null)
{
return(0);
}
EmailResultStatus emailResultStatus = emailResult.Status;
BulkEmailResponseCode response;
try {
response = emailResultStatus.GetBulkEmailResponseCode();
} catch (InvalidCastException) {
return(0);
}
Guid mandrillId;
if (!Guid.TryParse(emailResult.Id, out mandrillId))
{
return(0);
}
var recipientInfo = messageInfo.Recipients.FirstOrDefault() as BulkEmailRecipientInfo;
var insert = new Insert(_userConnection)
.Into("MandrillSentMessage")
.Set("MandrillId", Column.Parameter(mandrillId))
.Set("BulkEmailRId", Column.Parameter(messageInfo.MessageRId))
.Set("ContactRId", Column.Parameter(recipientInfo.ContactRId))
.Set("ResponseCode", Column.Parameter((int)response))
.Set("MailingStartTS", Column.Parameter(messageInfo.MailingStartTS));
return(insert.Execute());
}
/// <summary>
/// Lock/unlock execution of operations.
/// </summary>
/// <param name="conversationId">Conversation id.</param>
/// <param name="schemaName">Schema name.</param>
/// <param name="operationId">Deduplicat operation id.</param>
/// <param name="isLock">Lock state.</param>
public void SetLockState(Guid conversationId, string schemaName, Guid operationId, bool isLock)
{
Guid lockId;
var select = new Select(_userConnection)
.Column("Id").From("DeduplicateExecLocker")
.Where("EntitySchemaName").IsEqual(Column.Parameter(schemaName))
.And("OperationId").IsEqual(Column.Parameter(operationId)) as Select;
lockId = select.ExecuteScalar <Guid>();
if (lockId.IsNotEmpty())
{
var update = new Update(_userConnection, "DeduplicateExecLocker")
.Set("IsInProgress", Column.Parameter(isLock))
.Set("ConversationId", Column.Parameter(conversationId))
.Set("ModifiedOn", Column.Parameter(DateTime.UtcNow))
.Where("Id").IsEqual(Column.Parameter(lockId));
update.Execute();
}
else
{
var insert = new Insert(_userConnection).Into("DeduplicateExecLocker")
.Set("CreatedOn", Column.Parameter(DateTime.UtcNow))
.Set("ModifiedOn", Column.Parameter(DateTime.UtcNow))
.Set("EntitySchemaName", Column.Parameter(schemaName))
.Set("OperationId", Column.Parameter(operationId))
.Set("IsInProgress", Column.Parameter(isLock))
.Set("ConversationId", Column.Parameter(conversationId));
insert.Execute();
}
}
/// <summary>
/// Shows email on portal if CaseContact exists in ActivityParticipants.
/// </summary>
/// <param name="activity">Activity entity.</param>
/// <returns>True, if record was showed, otherwise - false.</returns>
/// <exception cref="NotSupportedException">Throws when <paramref name="activity"/> isn't an Activity.</exception>
public static bool ShowOnPortal(Entity activity)
{
if (activity.SchemaName != ActivitySchemaName)
{
throw new NotSupportedException();
}
var caseMessageHistoryId = GetCaseMesssageHistoryId(activity);
if (caseMessageHistoryId != Guid.Empty)
{
Guid id = Guid.NewGuid();
var insert = new Insert(activity.UserConnection)
.Into("PortalEmailMessage")
.Set("Id", Column.Parameter(id))
.Set("CaseMessageHistoryId", Column.Parameter(caseMessageHistoryId))
.Set("Recipient", Column.Parameter(activity.GetTypedColumnValue <string>("Recepient")))
.Set("Sender", Column.Parameter(activity.GetTypedColumnValue <string>("Sender")))
.Set("SendDate", Column.Parameter(activity.GetTypedColumnValue <DateTime>("SendDate")))
.Set("IsHtmlBody", Column.Parameter(activity.GetTypedColumnValue <bool>("IsHtmlBody")))
.Set("MessageTypeId", Column.Parameter(activity.GetTypedColumnValue <Guid>("MessageTypeId")));
bool insertExecuted = insert.Execute() == 1;
if (insertExecuted)
{
Guid sysAdminUnitId = activity.UserConnection.CurrentUser.Id;
_log.InfoFormat($"Record with Id {id} and CaseMessageHistoryId {caseMessageHistoryId} " +
$"was added by SysAdminUnit {sysAdminUnitId}");
}
return(insertExecuted);
}
return(false);
}
private int InsertUsersToTableByFilter(string tableCode, string filter)
{
// TODO ########### ########### ######### ############# ####### GetUsersByLdapFilter
var result = 0;
string[] userAttributes = GetUserAttributes();
string[] userRequiredAttributes = GetUserRequiredAttributes();
var request = new SearchRequest(_ldapUsersEntry, filter, SearchScope.Subtree, userAttributes);
PageResultRequestControl paging = CreatePageResultRequestControl();
request.Controls.Add(paging);
SortRequestControl sortControl = CreateSortRequestControl(_ldapUserLoginAttribute);
request.Controls.Add(sortControl);
do
{
SearchResponse response;
try {
response = _ldapConnection.SendRequest(request, RequestTimeout) as SearchResponse;
} catch (Exception exception) {
LogLdapRequestError(exception, request);
throw;
}
if (response.ResultCode == ResultCode.Success)
{
foreach (SearchResultEntry entry in response.Entries)
{
CheckEntryAttributes(entry, userRequiredAttributes);
LdapUser ldapUser = CreateLdapUser(entry, string.Empty);
var insertUser = new Insert(_userConnection).Into(tableCode)
.Set("Id", Column.Parameter(ldapUser.Id))
.Set("Name", Column.Parameter(ldapUser.Name))
.Set("ModifiedOn", Column.Parameter(ldapUser.ModifiedOn))
.Set("FullName", Column.Parameter(ldapUser.FullName))
.Set("Company", Column.Parameter(ldapUser.Company))
.Set("Email", Column.Parameter(ldapUser.Email))
.Set("Phone", Column.Parameter(ldapUser.Phone))
.Set("JobTitle", Column.Parameter(ldapUser.JobTitle))
.Set("IsActive", Column.Parameter(ldapUser.IsActive))
.Set("Dn", Column.Parameter(ldapUser.Dn));
try {
result += insertUser.Execute();
} catch (Exception e) {
_log.ErrorFormat("An error occurred while adding the record to the \"{0}\" table: {1}", e,
tableCode, e.Message);
throw;
}
}
}
else
{
_log.DebugFormat("Unable to obtain a list of users with the \"{0}\" filter. Result code: {1}.",
filter, response.ResultCode);
}
var responseControl = (PageResultResponseControl)Array.Find(response.Controls,
item => item is PageResultResponseControl);
paging.Cookie = responseControl.Cookie;
} while (paging.Cookie.Length != 0);
return(result);
}
protected void Add(ImportDataChunk <T> importDataChunk)
{
var insert = new Insert(UserConnection).Into(ImportSessionChunkSchemaName);
AddValuesToInsertQuery(insert, importDataChunk);
insert.Execute();
}
string CreateNewContact(string Name, string Email, UserConnection userConnection)
{
string result = string.Empty;
Guid Id = Guid.NewGuid();
Insert insert = new Insert(userConnection)
.Into("Contact")
.Set("Id", Column.Parameter(Id))
.Set("Name", Column.Parameter(Name))
.Set("Email", Column.Parameter(Email))
as Insert;
int resuCount = insert.Execute();
if (resuCount == 1)
{
return(Id.ToString());
}
else
{
return("Error");
}
//return result;
}
private void ChooseMoveToPerform(List<int> positions, TaskScore taskScore, BreakSchedule breakSchedule)
{
foreach(var position in positions)
{
Insert move = new Insert()
{
Solution = Solution,
Position = position,
TvBreak = breakSchedule.BreakData,
AdvertisementOrder = taskScore.AdConstraints,
};
move.Asses();
if(move.OverallDifference.HasScoreImproved() && !move.OverallDifference.AnyCompatibilityIssuesIncreased())
{
move.Execute();
Reporter.AddEntry(move.GenerateReportEntry());
_numberOfMoves += 1;
_movePerformed = true;
}
else
{
break;
}
if (CurrentTime.Elapsed >= TimeLimit) break;
}
}
/// <summary>
/// Saves the classification results.
/// </summary>
/// <param name="modelId">The model identifier.</param>
/// <param name="modelInstanceId">The model instance identifier.</param>
/// <param name="entityId">The entity identifier.</param>
/// <param name="results">Result, returned by ML service.</param>
public virtual void SavePrediction(Guid modelId, Guid modelInstanceId, Guid entityId,
List <ClassificationResult> results)
{
Query delete = new Delete(_userConnection)
.From("MLClassificationResult")
.Where("Key").IsEqual(Column.Parameter(entityId, "Guid"))
.And("ModelId").IsEqual(Column.Parameter(modelId, "Guid"));
delete.Execute();
foreach (ClassificationResult prediction in results)
{
var query = new Insert(_userConnection)
.Into("MLClassificationResult")
.Set("Id", Column.Parameter(Guid.NewGuid()))
.Set("CreatedOn", new QueryParameter(DateTime.UtcNow))
.Set("ModifiedOn", new QueryParameter(DateTime.UtcNow))
.Set("ModelId", new QueryParameter(modelId))
.Set("ModelInstanceUId", new QueryParameter(modelInstanceId))
.Set("Key", new QueryParameter(entityId))
.Set("Value", new QueryParameter(Guid.Parse(prediction.Value)))
.Set("Probability", new QueryParameter(prediction.Probability))
.Set("Significance", new QueryParameter(prediction.Significance));
query.Execute();
}
}
protected void MultiInsertCell(string schemaName, IEnumerable <Cell> cells)
{
var insert = new Insert(UserConnection).Into(schemaName);
foreach (var cell in cells)
{
if (!SafeValidateArguments(cell))
{
continue;
}
if (ForecastSheet.CheckForecastValueExceedMaxSize(UserConnection, cell.Value))
{
LogForecastValueExceedMaxSizeWarning(cell);
cell.Value = 0;
}
insert.Values()
.Set($"{PeriodColumnName}Id", Column.Parameter(cell.PeriodId))
.Set($"{ForecastColumnName}Id", Column.Parameter(cell.ColumnId))
.Set($"{SheetColumnName}Id", Column.Parameter(ForecastSheet.Id))
.Set($"{EntityColumnName}Id", Column.Parameter(cell.EntityId))
.Set($"{RowColumnName}Id", Column.Parameter(cell.RowId))
.Set(ValueColumnName, Column.Parameter(cell.Value));
}
if (insert.ColumnValues.IsNotEmpty())
{
insert.Execute();
}
}
public ActionResult Save(SiteRedirectModel model)
{
model.Title = model.LocalAddress;
if (model.ContentId == Guid.Empty)
{
Insert insertRedirect = UnigateObject.Insert("SiteRedirect", model);
var result = insertRedirect.Execute();
}
else
{
var result = UnigateObject.Update("SiteRedirect")
.Column("PageId", model.PageId)
.Column("Title", model.Title)
.Column("RouteAddress", model.RouteAddress)
.Column("LocalAddress", model.LocalAddress)
.Column("IsTemporary", model.IsTemporary)
.Column("TransferQuerystring", model.TransferQuerystring)
.WhereEqualTo("ContentId", model.ContentId).Execute();
ViewBag.Result = result.ResultMessage;
}
UnigateObject.Update("SiteMapLastUpdate")
.Column("SiteRedirectLastUpdateDate", DateTime.Now.ToString()).Execute();
return(RedirectToAction("Index"));
}
public void InsertErrorMessage(string logMessage)
{
Insert insert = new Insert(userConnection).Into("UsrIntegrationLogFtp")
.Set("UsrName", Column.Parameter("Загрузка файлов c папки OUTProducts"))
.Set("UsrErrorDescription", Column.Parameter(logMessage));
insert.Execute();
}
/// <summary>
/// Sets sync flag value to database.
/// </summary>
/// <param name="value">Sync flag value.</param>
/// <param name="userConnection"><see cref="UserConnection"/> instance.</param>
private void SetSyncKeyToDB(string value, UserConnection userConnection)
{
var insert = new Insert(userConnection)
.Into("EmailSynchronizedKey")
.Set("Name", Column.Parameter(value));
insert.Execute();
}
public void InsertErrorMessage(string logMessage)
{
Insert insert = new Insert(userConnection).Into("UsrIntegrationLogFtp")
.Set("UsrName", Column.Parameter("ServiceLog"))
.Set("UsrErrorDescription", Column.Parameter(logMessage));
insert.Execute();
}
public IEnumerable <string[]> Execute(params Value[] parameters)
{
if (ExecuteExists(parameters))
{
return(Update.Execute(parameters));
}
return(Insert.Execute(parameters));
}
public bool Execute(out int rowsAltered, params Value[] parameters)
{
if (ExecuteExists(parameters))
{
return(Update.Execute(out rowsAltered, parameters));
}
return(Insert.Execute(out rowsAltered, parameters));
}
/// <summary>
/// method to insert data to detail (many-to-many)
/// </summary>
/// <param name="sourceSchemaName">name of the deail object</param>
/// <param name="sourceColumnAlias1">name of the 1st column</param>
/// <param name="sourceExpression1">value to insert in 1st column</param>
/// <param name="sourceColumnAlias2">name of the 2nd column</param>
/// <param name="sourceExpression2">value to insert in 2nd column</param>
public void insert(string sourceSchemaName, string sourceColumnAlias1, string sourceExpression1, string sourceColumnAlias2, string sourceExpression2)
{
var insertPM = new Insert(userConnection).Into(sourceSchemaName)
.Set(sourceColumnAlias1, Column.Parameter(sourceExpression1))
.Set(sourceColumnAlias2, Column.Parameter(sourceExpression2));
insertPM.Execute();
}
public object Execute(Type type, params Value[] parameters)
{
if (ExecuteExists(parameters))
{
return(Update.Execute(type, parameters));
}
return(Insert.Execute(type, parameters));
}
private void SaveMessageInHistory(string messageId, string sysAdminUnitId, DateTime remindTime)
{
var insert = new Insert(_userConnection).Into(HISTORY_ENTITY_SCHEMA_NAME)
.Set("MessageId", Column.Parameter(messageId))
.Set("SysAdminUnitId", Column.Parameter(sysAdminUnitId))
.Set("RemindTime", Column.Parameter(remindTime));
insert.Execute();
}
private int InsertSocialUnsubscription(Guid sysAdminUnitId, Guid entityId)
{
var insert = new Insert(UserConnection).Into("SocialUnsubscription")
.Set("SysAdminUnitId", Column.Parameter(sysAdminUnitId))
.Set("EntityId", Column.Parameter(entityId));
var result = insert.Execute();
return(result);
}
public int InsertGroupsToTable(string tableCode)
{
// TODO ########### ########### ########### ###### ##### ####### GetGroups
_log.DebugFormat("Inserting group data into table {0}.", tableCode);
var result = 0;
string[] requiredGroupAttributes = GetRequiredGroupAttributes();
var request = new SearchRequest(_ldapGroupsEntry, _ldapGroupsFilter, SearchScope.Subtree,
requiredGroupAttributes);
PageResultRequestControl paging = CreatePageResultRequestControl();
request.Controls.Add(paging);
SortRequestControl sortControl = CreateSortRequestControl(_ldapGroupNameAttribute);
request.Controls.Add(sortControl);
do
{
SearchResponse response;
try {
response = _ldapConnection.SendRequest(request, RequestTimeout) as SearchResponse;
} catch (Exception exception) {
LogLdapRequestError(exception, request);
throw;
}
if (response.ResultCode == ResultCode.Success)
{
foreach (SearchResultEntry entry in response.Entries)
{
CheckEntryAttributes(entry, requiredGroupAttributes);
LdapGroup ldapGroup = CreateLdapGroup(entry);
var insertGroup = new Insert(_userConnection).Into(tableCode)
.Set("Id", Column.Parameter(ldapGroup.Id))
.Set("Name", Column.Parameter(ldapGroup.Name))
.Set("Dn", Column.Parameter(ldapGroup.Dn))
.Set("ModifiedOn", Column.Parameter(ldapGroup.ModifiedOn));
try {
result += insertGroup.Execute();
} catch (Exception e) {
_log.ErrorFormat("An error occurred while adding the record to the \"{0}\" table: {1}", e,
tableCode, e.Message);
throw;
}
}
}
else
{
_log.DebugFormat("Unable to obtain the list of folders. Result code: {0}. Error: {1}.",
response.ResultCode, response.ErrorMessage ?? string.Empty);
}
var responseControl = (PageResultResponseControl)Array.Find(response.Controls,
item => item is PageResultResponseControl);
paging.Cookie = responseControl.Cookie;
} while (paging.Cookie.Length != 0);
_log.DebugFormat("{0} group records added to table {1}.", result, tableCode);
return(result);
}
public void Update_GodArguments_TheQueryUpdateTheNewsRows()
{
IDatabaseContainer databaseContainer = ObjectConstructor.CreateDatabaseContainer();
string c1FirstRowData = "aaa";
string c2FirstRowData = "1";
string c1SecondRowData = "aaaa";
string c2SecondRowData = "2";
Database database = new Database("TestInsert3");
ITable table = new Table("table1");
Column column1 = new Column("c1", DataTypesFactory.GetDataTypesFactory().GetDataType(TypesKeyConstants.StringTypeKey));
Column column2 = new Column("c2", DataTypesFactory.GetDataTypesFactory().GetDataType(TypesKeyConstants.IntTypeKey));
Assert.IsTrue(column1.dataType.IsAValidDataType(c1FirstRowData));
Assert.IsTrue(column2.dataType.IsAValidDataType(c2FirstRowData));
Assert.IsTrue(column1.dataType.IsAValidDataType(c1SecondRowData));
Assert.IsTrue(column2.dataType.IsAValidDataType(c2SecondRowData));
table.AddColumn(column1);
table.AddColumn(column2);
database.AddTable(table);
databaseContainer.AddDatabase(database);
int rowCount = table.GetRowCount();
Select firstSelect = TestSelect.CreateSelect(databaseContainer, database.databaseName, table.tableName, true);
firstSelect.ValidateParameters();
firstSelect.Execute();
Assert.AreEqual(0, firstSelect.GetAfectedRowCount());
Insert insert = CreateInsert(databaseContainer, database.databaseName, table.tableName);
insert.AddValue(c1FirstRowData);
insert.AddValue(c2FirstRowData);
Assert.IsTrue(insert.ValidateParameters());
insert.Execute();
Select secondSelect = TestSelect.CreateSelect(databaseContainer, database.databaseName, table.tableName, true);
secondSelect.ValidateParameters();
secondSelect.Execute();
Assert.IsTrue(firstSelect.GetAfectedRowCount() < secondSelect.GetAfectedRowCount());
Assert.IsTrue(column1.GetCells(c1FirstRowData).Count > 0);
Assert.IsTrue(column2.GetCells(c2FirstRowData).Count > 0);
Assert.AreEqual(rowCount + 1, table.GetRowCount());
Update update = CreateUpdate(databaseContainer, database.databaseName, table.tableName);
update.AddValue(column1.columnName, c1FirstRowData);
update.AddValue(column2.columnName, c2FirstRowData);
Assert.IsTrue(update.ValidateParameters());
update.Execute();
Select thirdSelect = TestSelect.CreateSelect(databaseContainer, database.databaseName, table.tableName, true);
thirdSelect.ValidateParameters();
thirdSelect.Execute();
Assert.IsTrue(firstSelect.GetAfectedRowCount() < thirdSelect.GetAfectedRowCount());
Assert.IsTrue(column1.GetCells(c1FirstRowData).Count > 0);
Assert.IsTrue(column2.GetCells(c2FirstRowData).Count > 0);
Assert.AreEqual(rowCount + 1, table.GetRowCount());
}
/// <summary>
/// Create`s Case Message History record
/// </summary>
/// <param name="caseId">Case Id</param>
/// <param name="columnName">Name of updated column</param>
/// <param name="columnValue">Value of updated column</param>
private void CreateSatisfactionUpdateRecord(Guid caseId, string columnName, object columnValue)
{
var insert = new Insert(UserConnection)
.Into("SatisfactionUpdate")
.Set("CreatedOn", Column.Parameter(DateTime.UtcNow))
.Set("ModifiedOn", Column.Parameter(DateTime.UtcNow))
.Set("CaseId", new QueryParameter(caseId))
.Set(columnName, new QueryParameter(columnValue)) as Insert;
insert.Execute();
}
internal int InsertContact(Guid ContactId, string Name)
{
const string tableName = "Contact";
Insert insert = new Insert(UserConnection)
.Set("Id", Column.Parameter(ContactId))
.Set("Name", Column.Parameter(Name))
.Set("Email", Column.Parameter($"{Name}@creatio.com"))
.Into(tableName) as Insert;
return(insert.Execute());
}
public void insertToDate(DateTime data)
{
string sqlFormattedDate = data.ToString("yyyy-MM-dd");
var ins = new Insert(_userConnection)
.Into("UsrDetailEnd")
.Set("UsrEdition", Column.Parameter("Сгенерированная"))
.Set("UsrNexuslookUpId", Column.Parameter(new Guid(IdRecord)))
.Set("UsrDateEnd", Column.Parameter(sqlFormattedDate));
var affectedRows = ins.Execute();
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
if (EntityId == Guid.Empty || SysEntitySchemaId == Guid.Empty)
{
return(true);
}
var sysUserId = UserConnection.CurrentUser.Id;
using (var executor = UserConnection.EnsureDBConnection())
{
var select = new Select(UserConnection).Top(1)
.Column("Id")
.From("SysRecentEntity")
.Where("EntityId").IsEqual(Column.Parameter(EntityId))
.And("SysUserId").IsEqual(Column.Parameter(sysUserId))
as Select;
var id = default(Guid);
var isNew = true;
using (var rd = select.ExecuteReader(executor))
{
if (rd.Read())
{
id = new Guid(rd["Id"].ToString());
isNew = false;
}
}
if (isNew)
{
Insert insert = new Insert(UserConnection).Into("SysRecentEntity")
.Set("EntityId", Column.Parameter(EntityId))
.Set("EntityCaption", Column.Parameter(EntityDisplayName))
.Set("SysEntitySchemaUId", Column.Parameter(SysEntitySchemaId))
.Set("SysUserId", Column.Parameter(sysUserId))
.Set("UsedOn", Column.Parameter(System.DateTime.Now));
insert.Execute(executor);
}
else
{
Update update = new Update(UserConnection, "SysRecentEntity")
.Set("UsedOn", Column.Parameter(System.DateTime.Now))
.Where("Id").IsEqual(Column.Parameter(id)) as Update;
update.Execute(executor);
}
}
ClearExcessItems(sysUserId);
return(true);
}
/// <summary>
/// method to insert new pokemon to DB using properties of AnPokemonProxy object
/// </summary>
/// <param name="pokemon">object which needs to be inserted</param>
public void insert(AnPokemonProxy pokemon)
{
var insertPok = new Insert(userConnection).Into(sourceSchemaName)
.Set("AnName", Column.Parameter(pokemon.Name))
.Set("AnHeight", Column.Parameter(pokemon.Height))
.Set("AnWeight", Column.Parameter(pokemon.Weight))
.Set("AnWeightAndHeight", Column.Parameter(pokemon.Weight + pokemon.Height))
.Set("AnLookup_PokemonTypeId", Column.Parameter(pokemon.TypeId))
.Set("AnImageLinkId", Column.Parameter(pokemon.ImageId));
insertPok.Execute();
}
public void AddTask(UserConnection userConnection, Guid actionId, DateTime dateTime)
{
var insert = new Insert(userConnection)
.Into("AssistantTask")
.Set("Name", Column.Parameter(JobName))
.Set("ActionId", Column.Parameter(actionId))
.Set("SysAdminUnitId", Column.Parameter(userConnection.CurrentUser.Id))
.Set("RunDateTime", Column.Parameter(dateTime))
.Set("TypeId", Column.Parameter("53A1127D-B0C3-435B-9268-938F6678FDC2")) as Insert;
insert.Execute();
}
/// <summary>
/// Logged information about beginning execution of procedure.
/// </summary>
/// <param name="procedureName">Procedure name.</param>
/// <returns>Conversation id.</returns>
public Guid BeginConversation(string procedureName)
{
Guid conversationId = Guid.NewGuid();
var insert = new Insert(_userConnection).Into("DeduplicateExecLog")
.Set("Id", Column.Parameter(conversationId))
.Set("ProcedureName", Column.Parameter(procedureName))
.Set("CreatedOn", Column.Parameter(DateTime.UtcNow))
.Set("ExecutedOn", Column.Parameter(DateTime.UtcNow));
insert.Execute();
return(conversationId);
}
/// <summary>
/// Saves the many to many.
/// </summary>
private void SaveManyToMany()
{
foreach(TableSchema.ManyToManyRelationship m2m in ManyToManyCollection)
{
TableSchema.Table mapTable = DataService.GetSchema(m2m.MapTableName, ProviderName);
CheckBoxList chk = (CheckBoxList)FindControl(mapTable.ClassName);
if(chk != null)
{
ListItemCollection listItems = new ListItemCollection();
foreach(ListItem item in chk.Items)
{
if(item.Selected)
listItems.Add(item);
}
//using(TransactionScope ts = new TransactionScope())
//{
// using(SharedDbConnectionScope connScope = new SharedDbConnectionScope())
// {
SqlQuery qryDelete = new Delete().From(mapTable).Where(m2m.MapTableLocalTableKeyColumn).IsEqualTo(PrimaryKeyControlValue);
qryDelete.Execute();
foreach(ListItem selectedItem in listItems)
{
Insert qryInsert = new Insert(mapTable, false);
qryInsert.Value(mapTable.GetColumn(m2m.MapTableLocalTableKeyColumn), PrimaryKeyControlValue);
qryInsert.Value(mapTable.GetColumn(m2m.MapTableForeignTableKeyColumn), selectedItem.Value);
qryInsert.Execute();
}
// }
// ts.Complete();
//}
}
}
}
/// <summary>
/// Builds the insert SQL.
/// </summary>
/// <returns></returns>
protected void InsertRecord()
{
Insert qryInsert = new Insert(TableSchema, false);
foreach(TableSchema.TableColumn col in TableSchema.Columns)
{
if(!col.AutoIncrement && !col.IsReadOnly)
{
Control ctrl = FindControl(col.IsPrimaryKey ? PK_ID + col.ColumnName : col.ColumnName);
if(ctrl == null && col.IsPrimaryKey)
ctrl = FindControl(PK_ID);
if(ctrl != null)
{
object oVal = Utility.GetDefaultControlValue(col, ctrl, true, true);
bool insertValue = true;
if(col.DataType == DbType.Guid)
{
if(!Utility.IsMatch(col.DefaultSetting, SqlSchemaVariable.DEFAULT))
{
bool isEmptyGuid = Utility.IsMatch(oVal.ToString(), Guid.Empty.ToString());
if(col.IsNullable && isEmptyGuid)
oVal = null;
else if(col.IsPrimaryKey && isEmptyGuid)
oVal = Guid.NewGuid();
}
else
{
oVal = null;
insertValue = false;
}
}
else
oVal = TransformBooleanAndDateValues(oVal, col.DataType);
if(oVal == null)
oVal = DBNull.Value;
if(insertValue)
qryInsert.Value(col, oVal);
}
}
//if (col.DataType != DbType.Binary && col.DataType != DbType.Byte && Utility.IsWritableColumn(col))
//{
// if (!col.AutoIncrement && !(col.IsPrimaryKey && col.DataType == DbType.Guid))
// {
// Control ctrl = FindControl(col.ColumnName);
// if (ctrl != null)
// {
// object oVal = Utility.GetDefaultControlValue(col, ctrl, true, true);
// qryInsert.Value(col, oVal);
// }
// }
//}
}
qryInsert.Execute();
}
private int NewData(IConnectinContext cc, ObjectMapper om)
{
int result = 0;
Insert insert = new Insert(om.Table);
object value = null;
if (om.ID != null)
{
if (om.ID.Value != null)
{
if (!om.ID.Value.AfterByUpdate)
{
om.ID.Value.Executing(cc, this, om.ID,om.Table);
insert.AddField(om.ID.ColumnName, om.ID.Handler.Get(this));
}
}
else
{
insert.AddField(om.ID.ColumnName, om.ID.Handler.Get(this));
}
}
for(int i =0;i<om.Properties.Count;i++)
{
PropertyMapper pm = om.Properties[i];
if (!EntityState._FieldState.ContainsKey(pm.Handler.Property.Name))
{
if (pm.Value != null && !pm.Value.AfterByUpdate)
{
pm.Value.Executing(cc, this, pm, om.Table);
}
}
value = pm.Handler.Get(this);
if (EntityState._FieldState.ContainsKey(pm.Handler.Property.Name))
{
if (pm.Cast != null)
{
value = pm.Cast.ToColumn(value, pm.Handler.Property.PropertyType, this);
}
insert.AddField(pm.ColumnName, value);
}
}
result=insert.Execute(cc);
if (om.ID != null && om.ID.Value != null && om.ID.Value.AfterByUpdate)
om.ID.Value.Executed(cc, this, om.ID,om.Table);
return result;
}
