Ejemplo n.º 1
0
 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);
     }
 }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 3
0
        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());
        }
Ejemplo n.º 4
0
        /// <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);
        }
Ejemplo n.º 6
0
        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);
        }
Ejemplo n.º 7
0
        protected void Add(ImportDataChunk <T> importDataChunk)
        {
            var insert = new Insert(UserConnection).Into(ImportSessionChunkSchemaName);

            AddValuesToInsertQuery(insert, importDataChunk);
            insert.Execute();
        }
Ejemplo n.º 8
0
        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();
            }
        }
Ejemplo n.º 11
0
        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"));
        }
Ejemplo n.º 13
0
        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();
        }
Ejemplo n.º 14
0
        /// <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();
        }
Ejemplo n.º 16
0
 public IEnumerable <string[]> Execute(params Value[] parameters)
 {
     if (ExecuteExists(parameters))
     {
         return(Update.Execute(parameters));
     }
     return(Insert.Execute(parameters));
 }
Ejemplo n.º 17
0
 public bool Execute(out int rowsAltered, params Value[] parameters)
 {
     if (ExecuteExists(parameters))
     {
         return(Update.Execute(out rowsAltered, parameters));
     }
     return(Insert.Execute(out rowsAltered, parameters));
 }
Ejemplo n.º 18
0
        /// <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();
        }
Ejemplo n.º 19
0
 public object Execute(Type type, params Value[] parameters)
 {
     if (ExecuteExists(parameters))
     {
         return(Update.Execute(type, parameters));
     }
     return(Insert.Execute(type, parameters));
 }
Ejemplo n.º 20
0
        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();
        }
Ejemplo n.º 21
0
        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);
        }
Ejemplo n.º 22
0
        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);
        }
Ejemplo n.º 23
0
        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());
        }
Ejemplo n.º 24
0
        /// <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();
        }
Ejemplo n.º 25
0
        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());
        }
Ejemplo n.º 26
0
        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);
        }
Ejemplo n.º 28
0
        /// <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();
            }
Ejemplo n.º 30
0
        /// <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);
        }
Ejemplo n.º 31
0
        /// <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();
                    //}
                }
            }
        }
Ejemplo n.º 32
0
        /// <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();
        }
Ejemplo n.º 33
0
        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;
        }