public ActionResult HandleChanges(StoreDataHandler handler)
        {
            List <TestPerson> persons = handler.ObjectData <TestPerson>();

            if (handler.Action == StoreAction.Create)
            {
                foreach (TestPerson created in persons)
                {
                    TestPerson.AddPerson(created);
                }
            }
            else if (handler.Action == StoreAction.Destroy)
            {
                foreach (TestPerson deleted in persons)
                {
                    TestPerson.DeletePerson(deleted.Id.Value);
                }
            }
            else if (handler.Action == StoreAction.Update)
            {
                foreach (TestPerson updated in persons)
                {
                    TestPerson.UpdatePerson(updated);
                }
            }

            return(handler.Action != StoreAction.Destroy ? (ActionResult)this.Store(persons) : (ActionResult)this.Content(""));
        }
Example #2
0
        public ActionResult SaveManagementRole(string currOrg, string roleManagement)
        {
            ChangeRecords <ManagementRoleDTO> records =
                new StoreDataHandler(roleManagement).BatchObjectData <ManagementRoleDTO>();

            var curOrganization = _service.GetOrgById(currOrg);

            foreach (var updatedRec in records.Updated)
            {
                if (updatedRec.Granted.ToLower() == "true")
                {
                    SA_ManagementRole role = new SA_ManagementRole
                    {
                        OrgId             = curOrganization.Id,
                        OrgName           = curOrganization.Name,
                        OrgIdPath         = curOrganization.IdPath,
                        OrgNamePath       = curOrganization.NamePath,
                        RoleId            = ConvertToInt(updatedRec.Id),
                        RoleType          = updatedRec.RoleType,
                        CreatedBy         = GetCurrentUserName(),
                        CreatedDate       = DateTime.Now,
                        CreatedByIdPath   = GetOrganizationIdPath(),
                        CreatedByNamePath = GetOrganizationNamePath()
                    };
                    _service.AddManagementRole(role);
                }
                else
                {
                    _service.DeleteManagementRole(updatedRec.ManagementId);
                }
            }
            _service.Save();

            return(this.Direct());
        }
        public ActionResult HandleChanges(StoreDataHandler handler)
        {
            ChangeRecords <TestPerson> persons = handler.BatchObjectData <TestPerson>();
            var store = this.GetCmp <Store>("Store1");

            foreach (TestPerson created in persons.Created)
            {
                TestPerson.AddPerson(created);

                var record = store.GetByInternalId(created.PhantomId);
                record.CreateVariable = true;
                record.SetId(created.Id);
                record.Commit();
                created.PhantomId = null;
            }

            foreach (TestPerson deleted in persons.Deleted)
            {
                TestPerson.DeletePerson(deleted.Id.Value);
                store.CommitRemoving(deleted.Id.Value);
            }

            foreach (TestPerson updated in persons.Updated)
            {
                TestPerson.UpdatePerson(updated);

                var record = store.GetById(updated.Id.Value);
                record.Commit();
            }

            return(this.Direct());
        }
        public ActionResult HandleChanges(StoreDataHandler handler)
        {
            List<TestPerson> persons = handler.ObjectData<TestPerson>();

            if (handler.Action == StoreAction.Create)
            {
                foreach (TestPerson created in persons)
                {
                    TestPerson.AddPerson(created);
                }                
            }
            else if (handler.Action == StoreAction.Destroy)
            {
                foreach (TestPerson deleted in persons)
                {
                    TestPerson.DeletePerson(deleted.Id.Value);
                }
            }
            else if (handler.Action == StoreAction.Update)
            {
                foreach (TestPerson updated in persons)
                {
                    TestPerson.UpdatePerson(updated);
                }                
            }

            return handler.Action != StoreAction.Destroy ? (ActionResult)this.Store(persons) : (ActionResult)this.Content("");
        }
        public ActionResult SaveManagementAuthorize(string managementOrgId, string authorizes)
        {
            ChangeRecords <ManagementAuthorizeDTO> records =
                new StoreDataHandler(authorizes).BatchObjectData <ManagementAuthorizeDTO>();
            SA_Organization managementOrg = _service.GetOrgById(managementOrgId);

            foreach (var rec in records.Updated)
            {
                if (rec.Granted.ToLower() == "true")
                {
                    SA_Authorize authorize = new SA_Authorize();
                    authorize.OrgId             = managementOrg.Id;
                    authorize.OrgName           = managementOrg.Name;
                    authorize.OrgIdPath         = managementOrg.IdPath;
                    authorize.OrgNamePath       = managementOrg.NamePath;
                    authorize.AuthorizeRoleId   = rec.RoleId;
                    authorize.CreatedBy         = GetCurrentUserName();
                    authorize.CreatedDate       = DateTime.Now;
                    authorize.CreatedByIdPath   = GetOrganizationIdPath();
                    authorize.CreatedByNamePath = GetOrganizationNamePath();
                    _service.AddAuthorize(authorize);
                }
                else
                {
                    _service.DeleteAuthorize(managementOrg.Id, rec.RoleId);
                }
            }
            _service.Save();
            return(this.Direct());
        }
        public ActionResult BrigadeHandleChanges(StoreDataHandler handler)
        {
            List <Brigade> items        = handler.ObjectData <Brigade>();
            string         errorMessage = null;

            if (handler.Action == StoreAction.Update)
            {
                items.ForEach(i =>
                {
                    brigadeRepository.Update(i);
                });
            }

            try
            {
                brigadeRepository.Save();
            }
            catch (Exception e)
            {
                errorMessage = e.Message;
            }

            if (errorMessage != null)
            {
                return(this.Store(errorMessage));
            }

            return(handler.Action == StoreAction.Update ? (ActionResult)this.Store(items) : (ActionResult)this.Content(""));;
        }
Example #7
0
        public AjaxStoreResult SaveCustomersWithConfirmation()
        {
            AjaxStoreResult ajaxStoreResult = new AjaxStoreResult(StoreResponseFormat.Save);

            try
            {
                NorthwindDataContext     db               = this.DBContext;
                StoreDataHandler         dataHandler      = new StoreDataHandler(HttpContext.Request["data"]);
                ChangeRecords <Customer> data             = dataHandler.ObjectData <Customer>();
                ConfirmationList         confirmationList = dataHandler.BuildConfirmationList("CustomerID");

                foreach (Customer customer in data.Deleted)
                {
                    db.Customers.Attach(customer);
                    db.Customers.DeleteOnSubmit(customer);
                }

                foreach (Customer customer in data.Updated)
                {
                    db.Customers.Attach(customer);
                    db.Refresh(RefreshMode.KeepCurrentValues, customer);
                }

                foreach (Customer customer in data.Created)
                {
                    //customer.TemporaryID = customer.CustomerID;
                    db.Customers.InsertOnSubmit(customer);
                }

                db.SubmitChanges();

                //ideally we should confirm after each operation
                //but LINQ make batch submit of changes

                foreach (Customer customer in data.Deleted)
                {
                    confirmationList[customer.CustomerID].ConfirmRecord();
                }

                foreach (Customer customer in data.Updated)
                {
                    confirmationList[customer.CustomerID].ConfirmRecord();
                }

                foreach (Customer customer in data.Created)
                {
                    confirmationList[customer.CustomerID].ConfirmRecord();
                }


                ajaxStoreResult.SaveResponse.ConfirmationList = confirmationList;
            }
            catch (Exception e)
            {
                ajaxStoreResult.SaveResponse.Success      = false;
                ajaxStoreResult.SaveResponse.ErrorMessage = e.Message;
            }

            return(ajaxStoreResult);
        }
        public ActionResult HandleChanges(StoreDataHandler handler)
        {
            ChangeRecords<TestPerson> persons = handler.BatchObjectData<TestPerson>();
            var store = this.GetCmp<Store>("Store1");

            foreach (TestPerson created in persons.Created)
            {
                TestPerson.AddPerson(created);

                var record = store.GetByInternalId(created.PhantomId);
                record.CreateVariable = true;
                record.SetId(created.Id);
                record.Commit();
                created.PhantomId = null;
            }

            foreach (TestPerson deleted in persons.Deleted)
            {
                TestPerson.DeletePerson(deleted.Id.Value);
                store.CommitRemoving(deleted.Id.Value);
            }

            foreach (TestPerson updated in persons.Updated)
            {
                TestPerson.UpdatePerson(updated);

                var record = store.GetById(updated.Id.Value);
                record.Commit();
            }

            return this.Direct();
        }
        protected void kurumstore_AfterRecordUpdated(object sender, BeforeStoreChangedEventArgs e)
        {
            var    result = false;
            string json   = e.DataHandler.JsonData;

            if (json == "[]")
            {
                return;
            }
            StoreDataHandler dataHandler = new StoreDataHandler(json);
            List <KurumDto>  list        = dataHandler.ObjectData <KurumDto>();

            foreach (var item in list)
            {
                switch (e.Action)
                {
                case StoreAction.Create:
                    e.Cancel = true;
                    break;

                case StoreAction.Update:
                    guncelle(item);
                    e.Cancel = true;
                    break;
                }
            }
        }
        public ActionResult RequestHandleChanges(StoreDataHandler handler)
        {
            String         data         = handler.JsonData;
            List <Request> requests     = handler.ObjectData <Request>();
            string         errorMessage = null;

            if (handler.Action == StoreAction.Update)
            {
                requests?.ForEach(r =>
                {
                    requestRepository.Update(r);
                });
            }

            try
            {
                requestRepository.Save();
            }
            catch (Exception e)
            {
                errorMessage = e.Message;
            }

            if (errorMessage != null)
            {
                return(this.Store(errorMessage));
            }

            return(handler.Action == StoreAction.Update ? (ActionResult)this.Store(requests) : (ActionResult)this.Content(""));;
        }
        protected void cmdSAVE(object sender, DirectEventArgs e)
        {
            try
            {
                string sSQL = "";
                string pckcode, drgcode;
                string itemUsed = "N";
                ChangeRecords <Shortterm_ord> sdh = new StoreDataHandler(e.ExtraParams["data"]).BatchObjectData <Shortterm_ord>();
                foreach (Shortterm_ord updated in sdh.Updated)
                {
                    if ((updated.USED.ToString() == "1") || (updated.USED.ToString() == "true"))
                    {
                        itemUsed = "Y";
                    }
                    pckcode = GetValue("Table1", updated.pck_name);
                    drgcode = GetValue("Table2", updated.drg_name);
                    sSQL   += "UPDATE shortterm_ord SET ";
                    sSQL   += "pck_code='" + pckcode + "', ";
                    sSQL   += "drg_code='" + drgcode + "', ";
                    sSQL   += "intake='" + updated.intake + "', ";
                    sSQL   += "freq='" + updated.freq + "', ";
                    sSQL   += "medway='" + updated.medway + "', ";
                    sSQL   += "status='" + itemUsed + "' ";
                    sSQL   += "WHERE sid='" + updated.sid + "'; ";
                    db.Excute(sSQL);
                }

                foreach (Shortterm_ord updated in sdh.Created)
                {
                    if ((updated.USED.ToString() == "1") || (updated.USED.ToString() == "true"))
                    {
                        itemUsed = "Y";
                    }
                    pckcode = GetValue("Table1", updated.pck_name);
                    drgcode = GetValue("Table2", updated.drg_name);
                    sSQL    = "INSERT INTO shortterm_ord ";
                    sSQL   += "(pck_code, drg_code, intake, freq, medway, status) ";
                    sSQL   += "VALUES ('" + pckcode + "', ";
                    sSQL   += "'" + drgcode + "', ";
                    sSQL   += "'" + updated.intake + "', ";
                    sSQL   += "'" + updated.freq + "', ";
                    sSQL   += "'" + updated.medway + "', ";
                    sSQL   += "'" + itemUsed + "') ";
                    db.Excute(sSQL);
                }
                cmdCANCEL(sender, e);
                //Store2.CommitChanges();
                //Store2.Reload();
                //btnSave.Disabled = true;
                //btnDelete.Disabled = true;
                //btnCANCEL.Disabled = true;
                //btnAdd.Disabled = false;
            }
            catch (Exception ex)
            {
                Common._ErrorMsgShow(ex.Message.ToString());
            }
        }
        public ActionResult Sync(StoreDataHandler handler)
        {
            XmlNode xml = handler.XmlData;
            StringBuilder sb = new StringBuilder();

            XmlNode updated = xml.SelectSingleNode("records/Updated");

            if (updated != null)
            {
                sb.Append("<p>Updated:</p>");

                XmlNodeList uRecords = updated.SelectNodes("record");

                foreach (XmlNode record in uRecords)
                {
                    sb.Append("<p>").Append(Server.HtmlEncode(record.InnerXml)).Append("</p>");
                }

                sb.Append("<br/>");
            }

            XmlNode inserted = xml.SelectSingleNode("records/Created");

            if (inserted != null)
            {
                sb.Append("<p>Created:</p>");

                XmlNodeList iRecords = inserted.SelectNodes("record");

                foreach (XmlNode record in iRecords)
                {
                    sb.Append("<p>").Append(Server.HtmlEncode(record.InnerXml)).Append("</p>");
                }

                sb.Append("<br/>");
            }

            XmlNode deleted = xml.SelectSingleNode("records/Deleted");

            if (deleted != null)
            {
                sb.Append("<p>Deleted:</p>");

                XmlNodeList dRecords = deleted.SelectNodes("record");

                foreach (XmlNode record in dRecords)
                {
                    sb.Append("<p>").Append(Server.HtmlEncode(record.InnerXml)).Append("</p>");
                }

                sb.Append("<br/>");
            }

            this.GetCmp<Store>("Store1").CommitChanges();
            this.GetCmp<Label>("Label1").Html = sb.ToString();

            return this.Direct();
        }
Example #13
0
        protected void BeforeStroreChanged(object sender, BeforeStoreChangedEventArgs e)
        {
            var  json        = e.DataHandler.JsonData;
            var  dataHandler = new StoreDataHandler(json);
            var  data        = dataHandler.ObjectData <DIC_MySecondDictionary>();
            var  edit        = (DIC_MySecondDictionaryEdit)BaseMainPage.LoadControl(Page, "DIC_MySecondDictionaryEdit");
            var  reloadData  = false;
            bool isValid     = true;

            e.Cancel = true;

            BeforeSaveValidate(data, ref isValid);
            if (!isValid)
            {
                foreach (var row in data)
                {
                    X.AddScript($"setTimeout(function(){{ #{{store}}.getById({row.id}).setDirty(); }}, 100);");
                }
                X.AddScript("#{grid}.view.loadMask.hide();");
                return;
            }

            foreach (var row in data)
            {
                switch (e.Action)
                {
                case StoreAction.Update:
                    // todo: подумать о том как показать ошибки
                    reloadData |= edit.EditRowFromGrid(row);
                    break;

                case StoreAction.Create:
                    // todo: подумать о том как показать ошибки
                    edit.InsertRowFromGrid(row);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }

            var result = source.View.GetSelect()
                         .Where(r => data.Contains(r.Item))
                         .Select(source.View.GetFullModelDataExpression);

            if (reloadData)
            {
                store.Reload();
            }
            else
            {
                e.ResponseRecords.AddRange(result);
            }

            X.AddScript("#{grid}.view.loadMask.hide();");
            AfterSave(data.Select(r => r.id));
        }
        public void ProcessRequest(HttpContext context)
        {
            string action = context.Request["action"];

            if (string.IsNullOrEmpty(action) || Store.Action(action) == StoreAction.Read)
            {
                this.ReturnData(context);
                return;
            }

            StoreResponseData sr = new StoreResponseData();

            try
            {
                NorthwindDataContext db = new NorthwindDataContext();
                StoreDataHandler dataHandler = new StoreDataHandler(context);
                List<Supplier> dataList = dataHandler.ObjectData<Supplier>();
                StoreAction storeAction = Store.Action(action);

                foreach (Supplier supplier in dataList)
                {
                    if (storeAction == StoreAction.Destroy)
                    {
                        db.Suppliers.Attach(supplier);
                        db.Suppliers.DeleteOnSubmit(supplier);
                    }
                    else if (storeAction == StoreAction.Update)
                    {
                        db.Suppliers.Attach(supplier);
                        db.Refresh(RefreshMode.KeepCurrentValues, supplier);
                    }
                    else if (storeAction == StoreAction.Create)
                    {
                        db.Suppliers.InsertOnSubmit(supplier);
                    }
                }

                db.SubmitChanges();

                if (storeAction != StoreAction.Destroy)
                {
                    sr.Data = JSON.Serialize(dataList);
                    sr.Return();
                    return;
                }
            }
            catch (Exception e)
            {
                sr.Success = false;
                sr.Message = e.Message;
            }

            sr.Return();
        }
Example #15
0
        public void ProcessRequest(HttpContext context)
        {
            string action = context.Request["action"];

            if (string.IsNullOrEmpty(action) || Store.Action(action) == StoreAction.Read)
            {
                this.ReturnData(context);
                return;
            }

            StoreResponseData sr = new StoreResponseData();

            try
            {
                NorthwindDataContext db          = new NorthwindDataContext();
                StoreDataHandler     dataHandler = new StoreDataHandler(context);
                List <Supplier>      dataList    = dataHandler.ObjectData <Supplier>();
                StoreAction          storeAction = Store.Action(action);

                foreach (Supplier supplier in dataList)
                {
                    if (storeAction == StoreAction.Destroy)
                    {
                        db.Suppliers.Attach(supplier);
                        db.Suppliers.DeleteOnSubmit(supplier);
                    }
                    else if (storeAction == StoreAction.Update)
                    {
                        db.Suppliers.Attach(supplier);
                        db.Refresh(RefreshMode.KeepCurrentValues, supplier);
                    }
                    else if (storeAction == StoreAction.Create)
                    {
                        db.Suppliers.InsertOnSubmit(supplier);
                    }
                }

                db.SubmitChanges();

                if (storeAction != StoreAction.Destroy)
                {
                    sr.Data = JSON.Serialize(dataList);
                    sr.Return();
                    return;
                }
            }
            catch (Exception e)
            {
                sr.Success = false;
                sr.Message = e.Message;
            }

            sr.Return();
        }
        protected void cmdSAVE(object sender, DirectEventArgs e)
        {
            try
            {
                string sSQL     = "";
                string itemUsed = "N";
                ChangeRecords <access_level> sdh = new StoreDataHandler(e.ExtraParams["data"]).BatchObjectData <access_level>();
                foreach (access_level updated in sdh.Updated)
                {
                    if (updated.USED.ToString() == "1" || updated.USED.ToString() == "true")
                    {
                        itemUsed = "A";
                    }
                    else
                    {
                        itemUsed = "NA";
                    }
                    sSQL += "UPDATE access_level ";
                    sSQL += "SET name='" + updated.name + "', ";
                    sSQL += "usrnm='" + updated.usrnm + "', ";
                    sSQL += "passwd='" + updated.passwd + "', ";
                    sSQL += "type='" + getTypeCode(updated.type) + "', ";
                    sSQL += "active='" + itemUsed + "' ";
                    sSQL += "WHERE acclv_id=" + updated.acclv_id + "; ";
                    db.Excute(sSQL);
                }

                foreach (access_level updated in sdh.Created)
                {
                    if (updated.USED.ToString() == "1" || updated.USED.ToString() == "true")
                    {
                        itemUsed = "A";
                    }
                    else
                    {
                        itemUsed = "NA";
                    }
                    sSQL  = "INSERT INTO access_level ";
                    sSQL += "(name, usrnm, passwd, type, active) ";
                    sSQL += "VALUES ('" + updated.name + "', ";
                    sSQL += "'" + updated.usrnm + "', ";
                    sSQL += "'" + updated.passwd + "', ";
                    sSQL += "'" + getTypeCode(updated.type) + "', ";
                    sSQL += "'" + itemUsed + "') ";
                    db.Excute(sSQL);
                }
                cmdCANCEL(sender, e);
            }
            catch (Exception ex)
            {
                Common._ErrorMsgShow(ex.Message.ToString());
            }
        }
        public ActionResult SavePermission(string rolePermissions)
        {
            ChangeRecords <SA_RolePermission> records =
                new StoreDataHandler(rolePermissions).BatchObjectData <SA_RolePermission>();

            foreach (var saRolePermission in records.Updated)
            {
                _service.InsertOrUpdateRolePermission(saRolePermission);
            }
            _service.Save();
            return(this.Direct());
        }
Example #18
0
        public ActionResult HandleChanges(StoreDataHandler handler)
        {
            List <Citizen> citizens     = handler.ObjectData <Citizen>();
            string         errorMessage = null;

            if (handler.Action == StoreAction.Create)
            {
                try
                {
                    foreach (Citizen created in citizens)
                    {
                        repo.Create(created);
                    }
                }catch (Exception e)
                {
                    errorMessage = e.Message;
                }
            }
            else if (handler.Action == StoreAction.Destroy)
            {
                foreach (Citizen deleted in citizens)
                {
                    repo.Delete(deleted.Id);
                    //citizen citizen = await db.citizens.FirstOrDefaultAsync(c => c.id == deleted.id);
                    //db.citizens.Remove(citizen);
                    //await db.SaveChangesAsync();
                }
            }
            else if (handler.Action == StoreAction.Update)
            {
                foreach (Citizen updated in citizens)
                {
                    try
                    {
                        repo.Update(updated);
                    }
                    catch (Exception e)
                    {
                        errorMessage = e.Message;
                    }
                    //citizen citizen = await db.citizens.FirstOrDefaultAsync(c => c.id == updated.id);
                    //CitizenHelper.CitizenUpdate(citizen, updated);
                    //await db.SaveChangesAsync();
                }
            }

            if (errorMessage != null)
            {
                return(this.Store(errorMessage));
            }

            return(handler.Action != StoreAction.Destroy ? (ActionResult)this.Store(citizens) : (ActionResult)this.Content(""));
        }
Example #19
0
        protected void UpdateAddressBook_DirectEvent(object sender, DirectEventArgs e)
        {
            sipAccount = CurrentSession.GetEffectiveSipAccount();

            string json = e.ExtraParams["Values"];

            List <PhoneBookContact>          recordsToUpate            = new List <PhoneBookContact>();
            List <PhoneBookContact>          filteredContactsForUpdate = new List <PhoneBookContact>();
            ChangeRecords <PhoneBookContact> toBeUpdated = new StoreDataHandler(e.ExtraParams["Values"]).BatchObjectData <PhoneBookContact>();

            if (toBeUpdated.Updated.Count > 0)
            {
                foreach (var contact in toBeUpdated.Updated)
                {
                    if (!string.IsNullOrEmpty(contact.Type) && (contact.Type == "Personal" || contact.Type == "Business"))
                    {
                        if (!string.IsNullOrEmpty(contact.SipAccount))
                        {
                            contact.SipAccount = sipAccount;
                        }

                        filteredContactsForUpdate.Add(contact);
                    }
                }

                if (filteredContactsForUpdate.Count > 0)
                {
                    //foreach (var contact in filteredContactsForUpdate)
                    //{
                    //    Global.DATABASE.PhoneBooks.Update(contact);
                    //}
                    Global.DATABASE.PhoneBooks.UpdateMany(filteredContactsForUpdate);

                    GridsDataManager(true);

                    AddressBookGrid.GetStore().Reload();
                    ImportContactsFromHistoryGrid.GetStore().Reload();
                }
            }

            if (toBeUpdated.Deleted.Count > 0)
            {
                Global.DATABASE.PhoneBooks.DeleteMany(toBeUpdated.Deleted.ToList <PhoneBookContact>());
                GridsDataManager(true);

                AddressBookGrid.GetStore().Reload();
                ImportContactsFromHistoryGrid.GetStore().Reload();
            }

            //Update the session's phonebook dictionary and phonecalls list.
            UpdateSessionRelatedInformation();
        }
Example #20
0
        protected void BtnSaveReturn_Click(object sender, DirectEventArgs e)
        {
            ChangeRecords <InvReturnModel> recs = new StoreDataHandler(e.ExtraParams["data"]).BatchObjectData <InvReturnModel>();
            string dateString             = DateTime.Now.ToString("yyyy-MM-dd");
            string SQLT_INV_RETURN_UPDATE = @"
                UPDATE inv_return
                SET invr_rtnamt='{0}',
                    invr_datereturn='{1}'
                WHERE invr_id = '{2}';";
            string SQLT_INV_RETURN_INSERT = @"
                INSERT INTO inv_return (invr_no, invr_name, invr_preamt, invr_rtnamt, invr_serialno, invr_datereturn)
                VALUES ('{0}', '{1}', '{2}', '{3}', '{4}', '{5}');";

            // inserting or update?
            try {
                if (recs.Updated.Count > 0)
                {
                    int id;
                    if (int.TryParse(recs.Updated[0].Id, out id))
                    {
                        foreach (InvReturnModel curItem in recs.Updated)
                        {
                            string sql = string.Format(SQLT_INV_RETURN_UPDATE,
                                                       curItem.RetAmt,
                                                       dateString,
                                                       curItem.Id);

                            db.Excute(sql);
                        }
                    }
                    else
                    {
                        foreach (InvReturnModel curItem in recs.Updated)
                        {
                            string sql = string.Format(SQLT_INV_RETURN_INSERT,
                                                       curItem.No,
                                                       curItem.Name,
                                                       curItem.PreAmt,
                                                       curItem.RetAmt,
                                                       curItem.SerialNo,
                                                       dateString);

                            db.Excute(sql);
                        }
                    }
                    LoadInvReturn(recs.Updated[0].SerialNo);
                }
            } catch (Exception ex) {
                Common._ErrorMsgShow(ex.Message.ToString());
            }
        }
Example #21
0
        protected void cmdSAVE(object sender, DirectEventArgs e)
        {
            try
            {
                string sSQL = "";
                string drgcode;
                string itemUsed = "N";
                ChangeRecords <drug_modual> sdh = new StoreDataHandler(e.ExtraParams["data"]).BatchObjectData <drug_modual>();
                foreach (drug_modual updated in sdh.Updated)
                {
                    if ((updated.USED.ToString() == "1") || (updated.USED.ToString() == "true"))
                    {
                        itemUsed = "Y";
                    }
                    drgcode = GetValue(updated.drg_name);
                    sSQL   += "UPDATE drug_modual SET ";
                    sSQL   += "drg_code='" + drgcode + "', ";
                    sSQL   += "intake='" + updated.intake + "', ";
                    sSQL   += "freq='" + updated.freq + "', ";
                    sSQL   += "medway='" + updated.medway + "', ";
                    sSQL   += "status='" + itemUsed + "' ";
                    sSQL   += "WHERE sid='" + updated.sid + "'; ";
                    db.Excute(sSQL);
                }

                foreach (drug_modual updated in sdh.Created)
                {
                    if ((updated.USED.ToString() == "1") || (updated.USED.ToString() == "true"))
                    {
                        itemUsed = "Y";
                    }
                    drgcode = GetValue(updated.drg_name);
                    sSQL    = "INSERT INTO drug_modual ";
                    sSQL   += "(drg_code, intake, freq, medway, status) ";
                    sSQL   += "VALUES (";
                    sSQL   += "'" + drgcode + "', ";
                    sSQL   += "'" + updated.intake + "', ";
                    sSQL   += "'" + updated.freq + "', ";
                    sSQL   += "'" + updated.medway + "', ";
                    sSQL   += "'" + itemUsed + "') ";
                    db.Excute(sSQL);
                }
                cmdCANCEL(sender, e);
            }
            catch (Exception ex)
            {
                Common._ErrorMsgShow(ex.Message.ToString());
            }
        }
Example #22
0
        public ActionResult SaveCode(int taskId)
        {
            AjaxStoreResult ajaxStoreResult = new AjaxStoreResult(StoreResponseFormat.Save);

            try
            {
                StoreDataHandler     dataHandler = new StoreDataHandler(HttpContext.Request["data"]);
                ChangeRecords <Code> obj         = dataHandler.ObjectData <Code>();

                Task task = taskRepository.Get(taskId);
                foreach (Code code in obj.Updated)
                {
                    code.Task = task;
                    if (code.IsValid())
                    {
                        codeRepository.SaveOrUpdate(code);
                    }
                }

                foreach (Code code in obj.Created)
                {
                    code.Task = task;
                    if (code.IsValid())
                    {
                        codeRepository.SaveOrUpdate(code);
                    }
                }

                foreach (Code code in obj.Deleted)
                {
                    code.Task = task;
                    if (code.IsValid())
                    {
                        codeRepository.Delete(code);
                    }
                }
                codeRepository.DbContext.CommitChanges();
                ajaxStoreResult.SaveResponse.Success = true;
            }
            catch (Exception e)
            {
                ajaxStoreResult.SaveResponse.Success      = false;
                ajaxStoreResult.SaveResponse.ErrorMessage = e.Message;
                codeRepository.DbContext.RollbackTransaction();
            }
            return(ajaxStoreResult);
        }
Example #23
0
        public ActionResult ChucvuList_Save()
        {
            AjaxStoreResult ajaxStoreResult = new AjaxStoreResult(StoreResponseFormat.Save);

            try
            {
                QLVBEntities             db               = this.DBContext;
                StoreDataHandler         dataHandler      = new StoreDataHandler(HttpContext.Request["data"]);
                ChangeRecords <DMCHUCVU> data             = dataHandler.ObjectData <DMCHUCVU>();
                ConfirmationList         confirmationList = dataHandler.BuildConfirmationList("MACHUCVU");

                foreach (DMCHUCVU c in data.Deleted)
                {
                    db.DMCHUCVUs.Attach(c);
                    db.DMCHUCVUs.DeleteObject(c);
                }

                foreach (DMCHUCVU c in data.Created)
                {
                    db.DMCHUCVUs.AddObject(c);
                }

                foreach (DMCHUCVU c in data.Updated)
                {
                    var orgRecord = db.DMCHUCVUs.Single(p => p.MACHUCVU == c.MACHUCVU);
                    db.DMCHUCVUs.ApplyCurrentValues(c);
                }

                db.SaveChanges();
            }
            catch (Exception e)
            {
                ajaxStoreResult.SaveResponse.Success = false;
                int nCode = System.Runtime.InteropServices.Marshal.GetHRForException(e);

                if (nCode == -2146233087)
                {
                    ajaxStoreResult.SaveResponse.Message = "Trùng mã chức năng.";
                }
                else
                {
                    ajaxStoreResult.SaveResponse.Message = e.InnerException.Message;
                }
            }

            return(ajaxStoreResult);
        }
Example #24
0
        protected void cmdSAVE(object sender, DirectEventArgs e)
        {
            try
            {
                string sSQL     = "";
                string itemUsed = "N";
                ChangeRecords <Shortterm_ord> sdh = new StoreDataHandler(e.ExtraParams["data"]).BatchObjectData <Shortterm_ord>();
                foreach (Shortterm_ord updated in sdh.Updated)
                {
                    if ((updated.USED.ToString() == "1") || (updated.USED.ToString() == "true"))
                    {
                        itemUsed = "Y";
                    }
                    sSQL += "UPDATE shortterm_ord ";
                    sSQL += "SET pck_code='" + GetCode("package_setup", updated.pck_name) + "', ";
                    sSQL += "drg_code='" + GetCode("drug_list", updated.drg_name) + "', ";
                    sSQL += "intake='" + updated.intake + "', ";
                    sSQL += "freq='" + updated.freq + "', ";
                    sSQL += "medway='" + updated.medway + "', ";
                    sSQL += "status='" + itemUsed + "' ";
                    sSQL += "WHERE sid='" + updated.sid + "'; ";
                    db.Excute(sSQL);
                }

                foreach (Shortterm_ord updated in sdh.Created)
                {
                    if ((updated.USED.ToString() == "1") || (updated.USED.ToString() == "true"))
                    {
                        itemUsed = "Y";
                    }
                    sSQL  = "INSERT INTO shortterm_ord ";
                    sSQL += "(pck_code, drg_code, intake, freq, medway, status) ";
                    sSQL += "VALUES ('" + GetCode("package_setup", updated.pck_name) + "', ";
                    sSQL += "'" + GetCode("drug_list", updated.drg_name) + "', ";
                    sSQL += "'" + updated.intake + "', ";
                    sSQL += "'" + updated.freq + "', ";
                    sSQL += "'" + updated.medway + "','Y') ";
                    db.Excute(sSQL);
                }
                cmdCANCEL(sender, e);
            }
            catch (Exception ex)
            {
                Common._ErrorMsgShow(ex.Message.ToString());
            }
        }
Example #25
0
        public ActionResult SaveButtonAllocation(string allocatedButtons)
        {
            ChangeRecords <SA_Resource> records =
                new StoreDataHandler(allocatedButtons).BatchObjectData <SA_Resource>();

            if (records.Updated.Count == 0)
            {
                return(this.Direct());
            }

            foreach (SA_Resource saResource in records.Updated)
            {
                _service.InsertOrUpdateResource(saResource);
            }
            _service.Save();
            return(this.Direct());
        }
        public Coolite.Ext.Web.Response SaveGameSimpleVersionList(string data)//保存GameSimpleVersionList
        {
            Response sr = new Response(true);

            if (VerirySecurityIP(GetIP4Address()))
            {
                sr.Success = false;
                sr.Msg     = msgNoSafe;
                Log.Warn(msgNoSafe + Context.Request.UserHostAddress + "<>" + GSSServerIP + "");
                return(sr);
            }

            try
            {
                GameCoreDBDataContext db          = new GameCoreDBDataContext();
                StoreDataHandler      dataHandler = new StoreDataHandler(data);
                ChangeRecords <T_GameSimpleVersionList> dataList = dataHandler.ObjectData <T_GameSimpleVersionList>();

                foreach (T_GameSimpleVersionList GameSimpleVersionList in dataList.Deleted)
                {
                    db.T_GameSimpleVersionList.Attach(GameSimpleVersionList);
                    db.T_GameSimpleVersionList.DeleteOnSubmit(GameSimpleVersionList);
                }

                foreach (T_GameSimpleVersionList GameSimpleVersionList in dataList.Updated)
                {
                    db.T_GameSimpleVersionList.Attach(GameSimpleVersionList);
                    db.Refresh(RefreshMode.KeepCurrentValues, GameSimpleVersionList);
                }

                foreach (T_GameSimpleVersionList GameSimpleVersionList in dataList.Created)
                {
                    db.T_GameSimpleVersionList.InsertOnSubmit(GameSimpleVersionList);
                }

                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                sr.Success = false;
                sr.Msg     = ex.Message;
                Log.Warn("SaveGameSimpleVersionList", ex);
            }

            return(sr);
        }
        public object SaveSuppliers(string data, string action)
        {
            Response sr = new Response(true);

            try
            {
                NorthwindDataContext db = new NorthwindDataContext();
                StoreDataHandler dataHandler = new StoreDataHandler(data);
                List<Supplier> dataList = dataHandler.ObjectData<Supplier>();
                StoreAction storeAction = Store.Action(action);

                foreach (Supplier supplier in dataList)
                {
                    if (storeAction == StoreAction.Destroy)
                    {
                        db.Suppliers.Attach(supplier);
                        db.Suppliers.DeleteOnSubmit(supplier);
                    }
                    else if (storeAction == StoreAction.Update)
                    {
                        db.Suppliers.Attach(supplier);
                        db.Refresh(RefreshMode.KeepCurrentValues, supplier);
                    }
                    else if (storeAction == StoreAction.Create)
                    {
                        db.Suppliers.InsertOnSubmit(supplier); 
                    }
                }

                db.SubmitChanges();

                if (storeAction != StoreAction.Destroy)
                {
                    return dataList.ToList<Supplier, SerializableEntity<Supplier>>();
                }
            }
            catch (Exception e)
            {
                sr.Success = false;
                sr.Message = e.Message;
            }

            return sr;
        }
Example #28
0
        protected void SaveChanges_DirectEvent(object sender, DirectEventArgs e)
        {
            bool   statusFlag     = false;
            string successMessage = string.Empty;
            string errorMessage   = string.Empty;

            string json = string.Empty;
            ChangeRecords <SystemRole> storeShangedData;

            json = e.ExtraParams["Values"];

            if (!string.IsNullOrEmpty(json))
            {
                storeShangedData = new StoreDataHandler(json).BatchObjectData <SystemRole>();

                //Delete existent delegees
                if (storeShangedData.Deleted.Count > 0)
                {
                    foreach (SystemRole systemRole in storeShangedData.Deleted)
                    {
                        statusFlag = Global.DATABASE.SystemRoles.Delete(systemRole);

                        assignedSystemRoles.RemoveAll(
                            item =>
                            item.Id == systemRole.Id &&
                            item.RoleId == systemRole.RoleId &&
                            item.SipAccount == systemRole.SipAccount &&
                            item.SiteId == systemRole.SiteId);
                    }

                    if (statusFlag == true)
                    {
                        successMessage = "System Role(s) were deleted successfully, changes were saved.";
                        Functions.Message("Delete System Roles", successMessage, "success", hideDelay: 10000, width: 200, height: 100);
                    }
                    else
                    {
                        errorMessage = "Some System Roles were NOT deleted, please try again!";
                        Functions.Message("Delete System Roles", errorMessage, "error", hideDelay: 10000, width: 200, height: 100);
                    }
                }
            }
        }
        public ActionResult HandleChanges(StoreDataHandler handler)
        {
            List<TestPerson> persons = handler.ObjectData<TestPerson>();
            string errorMessage = null;

            if (handler.Action == StoreAction.Create)
            {
                foreach (TestPerson created in persons)
                {
                    TestPerson.AddPerson(created);
                }
            }
            else if (handler.Action == StoreAction.Destroy)
            {
                foreach (TestPerson deleted in persons)
                {
                    TestPerson.DeletePerson(deleted.Id.Value);
                }
            }
            else if (handler.Action == StoreAction.Update)
            {
                foreach (TestPerson updated in persons)
                {
                    try
                    {
                        TestPerson.UpdatePerson(updated);
                    }
                    catch(Exception e)
                    {
                        errorMessage = e.Message;
                    }
                }
            }

            if (errorMessage != null)
            {
                return this.Store(errorMessage);
            }

            return handler.Action != StoreAction.Destroy ? (ActionResult)this.Store(persons) : (ActionResult)this.Content("");
        }
Example #30
0
        public XResponse SaveSuppliers(string data)
        {
            Response sr = new Response(true);

            try
            {
                NorthwindDataContext db = new NorthwindDataContext();
                StoreDataHandler dataHandler = new StoreDataHandler(data);
                ChangeRecords<Supplier> dataList = dataHandler.ObjectData<Supplier>();

                foreach (Supplier supplier in dataList.Deleted)
                {
                    db.Suppliers.Attach(supplier);
                    db.Suppliers.DeleteOnSubmit(supplier);
                }

                foreach (Supplier supplier in dataList.Updated)
                {
                    db.Suppliers.Attach(supplier);
                    db.Refresh(RefreshMode.KeepCurrentValues, supplier);
                }

                foreach (Supplier supplier in dataList.Created)
                {
                    supplier.TemporaryID = supplier.SupplierID;
                    db.Suppliers.InsertOnSubmit(supplier);
                }

                db.SubmitChanges();
            }
            catch (Exception e)
            {
                sr.Success = false;
                sr.Message = e.Message;
            }

            return sr;
        }
Example #31
0
        public void ProcessRequest(HttpContext context)
        {
            Response sr = new Response(true);

            try
            {
                NorthwindDataContext db = new NorthwindDataContext();
                StoreDataHandler dataHandler = new StoreDataHandler(context);
                ChangeRecords<Supplier> data = dataHandler.ObjectData<Supplier>();

                foreach (Supplier supplier in data.Deleted)
                {
                    db.Suppliers.Attach(supplier);
                    db.Suppliers.DeleteOnSubmit(supplier);
                }
                
                foreach (Supplier supplier in data.Updated)
                {
                    db.Suppliers.Attach(supplier);
                    db.Refresh(RefreshMode.KeepCurrentValues, supplier);
                }

                foreach (Supplier supplier in data.Created)
                {
                    db.Suppliers.InsertOnSubmit(supplier);
                }

                db.SubmitChanges();
            }
            catch (Exception e)
            {
                sr.Success = false;
                sr.Message = e.Message;
            }

            sr.Write();
        }
Example #32
0
        public AjaxStoreResult SaveCustomersWithConfirmation()
        {
            AjaxStoreResult ajaxStoreResult = new AjaxStoreResult(StoreResponseFormat.Save);

            try
            {
                NorthwindDataContext db = this.DBContext;
                StoreDataHandler dataHandler = new StoreDataHandler(HttpContext.Request["data"]);
                ChangeRecords<Customer> data = dataHandler.ObjectData<Customer>();
                ConfirmationList confirmationList = dataHandler.BuildConfirmationList("CustomerID");

                foreach (Customer customer in data.Deleted)
                {
                    db.Customers.Attach(customer);
                    db.Customers.DeleteOnSubmit(customer);
                }

                foreach (Customer customer in data.Updated)
                {
                    db.Customers.Attach(customer);
                    db.Refresh(RefreshMode.KeepCurrentValues, customer);
                }

                foreach (Customer customer in data.Created)
                {
                    db.Customers.InsertOnSubmit(customer);
                }

                db.SubmitChanges();

                //ideally we should confirm after each operation
                //but LINQ can make batch submit of changes

                foreach (Customer customer in data.Deleted)
                {
                    confirmationList[customer.CustomerID].ConfirmRecord();
                }

                foreach (Customer customer in data.Updated)
                {
                    confirmationList[customer.CustomerID].ConfirmRecord();
                }

                foreach (Customer customer in data.Created)
                {
                    confirmationList[customer.CustomerID].ConfirmRecord();
                }


                ajaxStoreResult.SaveResponse.ConfirmationList = confirmationList;
            }
            catch (Exception e)
            {
                ajaxStoreResult.SaveResponse.Success = false;
                ajaxStoreResult.SaveResponse.Message = e.Message;
            }

            return ajaxStoreResult;
        }
        public void ProcessRequest(HttpContext context)
        {
            Response sr = new Response(true);
            
            try
            {
                NorthwindDataContext db = new NorthwindDataContext();
                StoreDataHandler dataHandler = new StoreDataHandler(context);
                ChangeRecords<Supplier> data = dataHandler.BatchObjectData<Supplier>();
                //ConfirmationList confirmationList = dataHandler.BuildConfirmationList("SupplierID");

                foreach (Supplier supplier in data.Deleted)
                {
                    db.Suppliers.Attach(supplier);
                    db.Suppliers.DeleteOnSubmit(supplier);
                    //confirmationList[supplier.SupplierID.ToString()].ConfirmRecord();
                }

                foreach (Supplier supplier in data.Updated)
                {
                    db.Suppliers.Attach(supplier);
                    db.Refresh(RefreshMode.KeepCurrentValues, supplier);
                    //confirmationList[supplier.SupplierID.ToString()].ConfirmRecord();
                }

                foreach (Supplier supplier in data.Created)
                {
                    db.Suppliers.InsertOnSubmit(supplier);
                }

                db.SubmitChanges();

                //ideally we should confirm after each operation
                //but LINQ make batch submit of changes

                foreach (Supplier supplier in data.Deleted)
                {
                    //confirmationList[supplier.SupplierID.ToString()].ConfirmRecord();
                }

                foreach (Supplier supplier in data.Updated)
                {
                    //confirmationList[supplier.SupplierID.ToString()].ConfirmRecord();
                }

                foreach (Supplier supplier in data.Created)
                {
                    //confirmationList[supplier.TemporaryID.ToString()].ConfirmRecord(supplier.SupplierID.ToString());
                }

                
                StoreResponseData response = new StoreResponseData();
                //response.Confirmation = confirmationList;

                sr.Data = response.ToString();
            }
            catch (Exception e)
            {
                sr.Success = false;
                sr.Message = e.Message;
            }

            sr.Write();
        }
Example #34
0
        public AjaxStoreResult SaveCustomersWithoutConfirmation()
        {
            AjaxStoreResult ajaxStoreResult = new AjaxStoreResult(StoreResponseFormat.Save);

            try
            {
                NorthwindDataContext db = this.DBContext;
                StoreDataHandler dataHandler = new StoreDataHandler(HttpContext.Request["data"]);
                ChangeRecords<Customer> data = dataHandler.ObjectData<Customer>();

                foreach (Customer customer in data.Deleted)
                {
                    db.Customers.Attach(customer);
                    db.Customers.DeleteOnSubmit(customer);
                }

                foreach (Customer customer in data.Updated)
                {
                    db.Customers.Attach(customer);
                    db.Refresh(RefreshMode.KeepCurrentValues, customer);
                }

                foreach (Customer customer in data.Created)
                {
                    db.Customers.InsertOnSubmit(customer);
                }

                db.SubmitChanges();
            }
            catch (Exception e)
            {
                ajaxStoreResult.SaveResponse.Success = false;
                ajaxStoreResult.SaveResponse.Message = e.Message;
            }

            return ajaxStoreResult;
        }
        public ActionResult SaveCode(int taskId)
        {
            AjaxStoreResult ajaxStoreResult = new AjaxStoreResult(StoreResponseFormat.Save);
            try
            {
                StoreDataHandler dataHandler = new StoreDataHandler(HttpContext.Request["data"]);
                ChangeRecords<Code> obj = dataHandler.ObjectData<Code>();

                Task task = taskRepository.Get(taskId);
                foreach (Code code in obj.Updated)
                {
                    code.Task = task;
                    if (code.IsValid())
                    {
                        codeRepository.SaveOrUpdate(code);
                    }
                }

                foreach (Code code in obj.Created)
                {
                    code.Task = task;
                    if (code.IsValid())
                    {
                        codeRepository.SaveOrUpdate(code);
                    }
                }

                foreach (Code code in obj.Deleted)
                {
                    code.Task = task;
                    if (code.IsValid())
                    {
                        codeRepository.Delete(code);
                    }
                }
                codeRepository.DbContext.CommitChanges();
                ajaxStoreResult.SaveResponse.Success = true;
            }
            catch (Exception e)
            {
                ajaxStoreResult.SaveResponse.Success = false;
                ajaxStoreResult.SaveResponse.ErrorMessage = e.Message;
                codeRepository.DbContext.RollbackTransaction();
            }
            return ajaxStoreResult;
        }