Пример #1
0
        public static void Set(IItem item, PropertyDefinition propertyDefinition, RemindersState <T> newState)
        {
            Util.ThrowOnNullArgument(item, "item");
            Util.ThrowOnNullArgument(propertyDefinition, "propertyDefinition");
            Util.ThrowOnMismatchType <byte[]>(propertyDefinition, "propertyDefinition");
            ExTraceGlobals.RemindersTracer.TraceDebug <StoreObjectId, PropertyDefinition>(0L, "RemindersState.Set - item={0}, propertyDefinition={1}", item.StoreObjectId, propertyDefinition);
            if (newState == null)
            {
                ExTraceGlobals.RemindersTracer.TraceDebug <PropertyDefinition>(0L, "RemindersState.Set - newState is null, deleting property={0}", propertyDefinition);
                item.Delete(propertyDefinition);
                return;
            }
            RemindersState <T> .ValidateStateIdentifiers(newState);

            ExTraceGlobals.RemindersTracer.TraceDebug <int>(0L, "RemindersState.Set - Serializing reminder states, count={0}", newState.StateList.Count);
            using (Stream stream = item.OpenPropertyStream(propertyDefinition, PropertyOpenMode.Create))
            {
                if (newState.StateList.Count > 0)
                {
                    IReminderState reminderState = newState.StateList[0];
                    newState.Version = reminderState.GetCurrentVersion();
                }
                using (XmlWriter xmlWriter = XmlWriter.Create(stream))
                {
                    DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(RemindersState <T>));
                    dataContractSerializer.WriteObject(xmlWriter, newState);
                }
            }
        }
        public async Task <ActionResult <ItemDTO> > DeleteItem(int id)
        {
            await _item.Delete(id);

            await _log.CreateLog(HttpContext, User.FindFirst("UserName").Value);

            return(NoContent());
        }
        public ActionResult Delete(int id)
        {
            var itemFromDb = _itemService.Get(id);

            if (itemFromDb == null)
            {
                return(NotFound());
            }
            _itemService.Delete(itemFromDb);
            _itemService.SaveChanges();
            return(NoContent());
        }
Пример #4
0
        public ActionResult RemoveItem(long id)
        {
            Func <ExtResult> removeFun = () =>
            {
                dalItem.Delete(id);
                var ret = new ExtResult();
                ret.success = true;
                return(ret);
            };

            return(base.Remove(removeFun));
        }
Пример #5
0
        public IActionResult Delete(string id)
        {
            var userId = HttpContext.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
            var item   = _itemService.GetItem(id, userId);

            if (item == null)
            {
                return(NotFound());
            }

            _itemService.Delete(item.Id, userId);
            return(NoContent());
        }
Пример #6
0
        public RedirectToActionResult Delete(int id)
        {
            if (!_session.ChkSession())
            {
                return(RedirectToAction("Login", "Auth"));
            }
            var obj = _item.GetItem(id);

            if (obj == null || !_item.Delete(obj))
            {
                return(RedirectToAction("List", new { msg = "Ошибка (объект не найден)" }));
            }
            return(RedirectToAction("List"));
        }
Пример #7
0
        public void MenuItem()
        {
            int Choice;

            Console.WriteLine("=====================================");
            Console.WriteLine("=======     MENU ITEM     ======");
            Console.WriteLine("=====================================");
            Console.WriteLine("||        1. View All Data          ||");
            Console.WriteLine("||        2. Insert                 ||");
            Console.WriteLine("||        3. Update                 ||");
            Console.WriteLine("||        4 Delete                  ||");
            Console.WriteLine("======================================");
            Console.Write("Pilihan.....");
            Choice = Convert.ToInt16(Console.ReadLine());
            switch (Choice)
            {
            case 1:
                iItem.get();
                Console.Read();
                break;

            case 2:
                iItem.insert(item);
                Console.Read();
                break;

            case 3:
                iItem.Update(Id, item);
                Console.Read();
                break;

            case 4:
                iItem.Delete(Id);
                Console.Read();
                break;

            default:
                Console.WriteLine("Exiting......");
                Console.Read();
                break;
            }
            Console.Read();
        }
Пример #8
0
        public IHttpActionResult Delete(int id)
        {
            try
            {
                var item = _repository.GetByID(id);

                if (item == null)
                {
                    return(NotFound());
                }

                _repository.Delete(id);

                return(Ok());
            }
            catch (System.Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Пример #9
0
 public ItemBO Delete(string id)
 {
     return(_item.Delete(id));
 }
Пример #10
0
        public async Task <IActionResult> DeleteConfirmed(int id)
        {
            await _item.Delete(id);

            return(RedirectToAction(nameof(Index)));
        }
Пример #11
0
        public void TestCreate()
        {
            string testFolderName = "porttest";

            if (Session.ExistsPath("/", testFolderName))
            {
                ICmisObject obj = Session.GetObjectByPath("/", testFolderName, OperationContextUtils.CreateMinimumOperationContext());
                if (obj is IFolder)
                {
                    ((IFolder)obj).DeleteTree(true, UnfileObject.Delete, true);
                }
                else
                {
                    obj.Delete();
                }
            }

            // create folder
            IFolder root      = Session.GetRootFolder();
            IFolder newFolder = CreateFolder(root, testFolderName);

            Assert.IsNotNull(newFolder);

            // create document
            string    contentString = "Hello World";
            IDocument newDoc        = CreateTextDocument(newFolder, "test.txt", contentString);

            Assert.IsNotNull(newDoc);

            // get content
            IContentStream newContent = newDoc.GetContentStream();

            Assert.IsNotNull(newContent);
            Assert.IsNotNull(newContent.Stream);

            Assert.AreEqual(contentString, ConvertStreamToString(newContent.Stream));

            // fetch it again to get the updated content stream length property
            IOperationContext ctxt   = OperationContextUtils.CreateMaximumOperationContext();
            ICmisObject       newObj = Session.GetObject(newDoc, ctxt);

            Assert.IsTrue(newObj is IDocument);
            IDocument newDoc2 = (IDocument)newObj;

            Assert.AreEqual(newDoc.Name, newDoc2.Name);
            Assert.AreEqual(Encoding.UTF8.GetBytes(contentString).Length, newDoc2.ContentStreamLength);

            // fetch it again
            newObj = Session.GetLatestDocumentVersion(newDoc, ctxt);
            Assert.IsTrue(newObj is IDocument);
            IDocument newDoc3 = (IDocument)newObj;

            Assert.AreEqual(newDoc.Id, newDoc3.Id);
            Assert.AreEqual(newDoc.Name, newDoc3.Name);

            // delete document
            newDoc.Delete();

            try
            {
                Session.GetObject(newDoc);
                Assert.Fail("Document still exists.");
            }
            catch (CmisObjectNotFoundException)
            {
                // expected
            }

            Assert.IsFalse(Session.Exists(newDoc.Id));


            // try an item
            IList <IObjectType> types = Session.GetTypeChildren(null, false).ToList();

            Assert.IsNotNull(types);
            Assert.IsTrue(types.Count >= 2);
            if (types.Any(type => type.Id == "cmis:item"))
            {
                IItem newItem = CreateItem(newFolder, "testItem");

                newItem.Delete();

                Assert.IsFalse(Session.Exists(newItem.Id));
            }


            // delete folder

            Assert.IsTrue(Session.ExistsPath(newFolder.Path));

            newFolder.Delete();

            Assert.IsFalse(Session.Exists(newFolder));
        }
Пример #12
0
        public IHttpActionResult AlteraStatus(int id, bool aprovado)
        {
            try
            {
                var os = _repository.GetByID(id);

                if (os == null)
                {
                    return(NotFound());
                }

                if (aprovado)
                {
                    os.Status = Enums.StatusOrdemServico.APROVADO;

                    if (os.OrdemServicoMotivo.AcaoFinal == Enums.AcaoFinalOrdemServico.EXCLUIR_ITEM)
                    {
                        var osItens = _itemRepository.GetByOrdemServicoID(os.ID);

                        foreach (var item in osItens)
                        {
                            _itRepository.Delete(item.ItemID);
                        }
                    }

                    if (os.OrdemServicoMotivo.AcaoFinal == Enums.AcaoFinalOrdemServico.ATUALIZAR_LOCAL_DESTINO)
                    {
                        var osMotivoID = os.OrdemServicoMotivoID;

                        var osCampoLocalDestinoID = _campoRepository.GetByName("LocalDestinoID").ID;

                        var osMotivoCampoLocalDestinoID = _motivoCampoRepository.GetByMotivoCampo(osMotivoID, osCampoLocalDestinoID).ID;

                        var osMotivoCampoValorLocalDestino = Convert.ToInt32(_valorRepository.Get(os.ID, osMotivoCampoLocalDestinoID).Valor);

                        var osItens = _itemRepository.GetByOrdemServicoID(os.ID);

                        foreach (var osItem in osItens)
                        {
                            var item = osItem.Item;

                            item.LocalID = osMotivoCampoValorLocalDestino;

                            _itRepository.Update(item, true);
                        }
                    }
                }
                else
                {
                    os.Status = Enums.StatusOrdemServico.REPROVADO;
                }

                _repository.Update(os);

                return(Ok(os));
            }
            catch (System.Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Пример #13
0
        public async Task <IActionResult> UpdateCell()
        {
            try
            {
                string requestGuid = Common.GetGuidFromURL(Request.Path.ToString()); //Get guid from query string
                Guid   libraryGuid = (requestGuid == null) ? Guid.Empty : (requestGuid == "") ? Guid.Empty : Guid.Parse(requestGuid);
                if (HttpContext.Request.Form["action"].ToString() == "create")       //insert
                {
                    Item item = new Item();
                    item.LibraryGuid = libraryGuid;
                    item.Deleted     = 0;
                    await _iItem.Add(item);

                    List <DataTableValidateMessage> validate = new List <DataTableValidateMessage>();
                    List <FieldValue> newRecord = new List <FieldValue>();
                    foreach (var key in HttpContext.Request.Form.Keys)
                    {
                        if (key != "action")
                        {
                            string fieldName  = key.Replace("data[0][", "").Replace("]", "");
                            string keyValue   = HttpContext.Request.Form[key].ToString();
                            var    fieldValue = await _iField.FindByNameAndLibraryGuid(fieldName, libraryGuid);

                            FieldValue value = new FieldValue();
                            //value.Field = fieldValue;
                            value.LibraryGuid = libraryGuid;
                            var validation = ValidateForm(fieldValue, HttpContext.Request.Form[key].ToString());
                            if (validation.Status == null)
                            {
                                if (validate.Count == 0)
                                {
                                    value.Item     = item;
                                    value.Value    = keyValue;
                                    value.ItemGuid = item.GUID;
                                    value.Created  = DateTime.Now;
                                    value.FieldID  = fieldValue.ID;
                                    newRecord.Add(value);
                                    //await _iFieldValue.Add(value);
                                }
                            }
                            else
                            {
                                validate.Add(validation);
                            }
                        }
                    }
                    if (validate.Count > 0)
                    {
                        return(new JsonResult(new { fieldErrors = validate }));
                    }
                    else
                    {
                        foreach (var newValue in newRecord)
                        {
                            await _iFieldValue.Add(newValue);
                        }
                        return(new JsonResult(new { result = "New record has been updated." }));
                    }
                }
                else if (HttpContext.Request.Form["action"].ToString() == "edit")//cell update
                {
                    foreach (var key in HttpContext.Request.Form.Keys)
                    {
                        if (key != "action")
                        {
                            string[] keys   = Common.getUpdateKey(key);
                            int      itemID = Convert.ToInt32(keys[0].ToString());
                            var      item   = await _iItem.FindByID(itemID);

                            var filedName  = keys[1].ToString();
                            var fieldValue = await _iFieldValue.FindbyNameAndLibraryGuidAndItemID(filedName, libraryGuid, itemID);

                            if (fieldValue == null) //propably new field just added to to the library, no field record has been added yet. Add new field to library record
                            {
                                var newField = await _iField.FindByNameAndLibraryGuid(filedName, libraryGuid);

                                fieldValue = new FieldValue();
                                //fieldValue.Field = newField;
                                fieldValue.Value = HttpContext.Request.Form[key].ToString();
                                var validation = ValidateForm(newField, HttpContext.Request.Form[key].ToString());
                                if (validation.Status == null)
                                {
                                    fieldValue.Item        = item;
                                    fieldValue.FieldID     = newField.ID;
                                    fieldValue.ItemGuid    = item.GUID;
                                    fieldValue.LibraryGuid = libraryGuid;
                                    fieldValue.Updated     = DateTime.Now;
                                    await _iFieldValue.Add(fieldValue);
                                }
                                else
                                {
                                    return(new JsonResult(new { status = false, result = validation.Status }));
                                }
                            }
                            else
                            {
                                var validation = ValidateForm(fieldValue.Field, HttpContext.Request.Form[key].ToString());
                                if (validation.Status == null)
                                {
                                    fieldValue.Value   = HttpContext.Request.Form[key].ToString();
                                    fieldValue.Updated = DateTime.Now;
                                    await _iFieldValue.Update(fieldValue);
                                }
                                else
                                {
                                    return(new JsonResult(new { status = false, result = validation.Status }));
                                }
                            }
                            return(new JsonResult(new { status = true, value = HttpContext.Request.Form[key].ToString(), result = filedName + " value " + fieldValue.Value + " has been updated" }));
                        }
                    }
                }
                else if (HttpContext.Request.Form["action"].ToString() == "remove")//remove)
                {
                    string[] keys = Common.getUpdateKey(HttpContext.Request.Form.Keys.ToArray()[0]);
                    await _iItem.Delete(Convert.ToInt32(keys[0]));

                    return(new JsonResult(new { result = "Record has been deleted" }));
                }
                return(new JsonResult(new { result = "success" }));
            }
            catch (Exception ex)
            {
                return(new JsonResult(new { result = ex.Message }));
            }
        }
Пример #14
0
 public void Delete(Item objItem)
 {
     Itemobj1.Delete(objItem);
 }