Example #1
0
        public ActionResult GetItemYamlWithChildren(RevisionModel data)
        {
            var guid = Guid.Parse(data.Id);

            using (new SecurityDisabler())
            {
                IItemData   item          = _sitecore.GetItemData(guid);
                var         localRev      = _sitecore.GetItemAndChildrenRevision(guid);
                List <Guid> GrandChildren = new List <Guid>();
                var         items         = new List <KeyValuePair <Guid, string> >();
                if (data.Rev == null || !data.Rev.ContainsKey(item.Id) || data.Rev[item.Id] != localRev[item.Id])
                {
                    using (var stream = new MemoryStream())
                    {
                        _yamlSerializationService.WriteSerializedItem(item, stream);
                        stream.Seek(0, SeekOrigin.Begin);

                        using (var reader = new StreamReader(stream))
                        {
                            items.Add(new KeyValuePair <Guid, string>(item.Id, reader.ReadToEnd()));
                        }
                    }
                }
                else
                {
                    items.Add(new KeyValuePair <Guid, string>(item.Id, null));
                }
                if (item.Path.StartsWith("/sitecore/media library/"))
                {
                    GrandChildren.AddRange(_sitecore.GetChildren(item).Select(x => x.Id));
                }
                else
                {
                    items.AddRange(_sitecore.GetChildren(item).Select(x =>
                    {
                        GrandChildren.AddRange(_sitecore.GetChildren(x).Select(c => c.Id));
                        if (data.Rev != null && data.Rev.ContainsKey(x.Id) && localRev.ContainsKey(x.Id) && data.Rev[x.Id] == localRev[x.Id])
                        {
                            return(new KeyValuePair <Guid, string>(x.Id, null));
                        }
                        using (var stream = new MemoryStream())
                        {
                            _yamlSerializationService.WriteSerializedItem(x, stream);
                            stream.Seek(0, SeekOrigin.Begin);

                            using (var reader = new StreamReader(stream))
                            {
                                return(new KeyValuePair <Guid, string>(x.Id, reader.ReadToEnd()));
                            }
                        }
                    }));
                }
                return(ScsJson(new ChildrenItemDataModel
                {
                    Items = items,
                    GrandChildren = GrandChildren
                }));
            }
        }
Example #2
0
        public async Task <(RustCategory, RustEditCategoryResult)> UpdateCategoryAsync(RustShopViewModel model)
        {
            var userForLog = await _userManager.FindByEmailAsync(_httpContextAccessor.HttpContext.User.Identity.Name);

            if (model.RustCategoryEditViewModel.Category.Id is null)
            {
                var shop = GetShopById(Guid.Parse(model.Id));

                if (shop is null)
                {
                    return(null, RustEditCategoryResult.Failed);
                }

                RustCategory newCategory = new RustCategory
                {
                    Id      = Guid.NewGuid(),
                    Index   = 1,
                    Name    = model.RustCategoryEditViewModel.Category.Name,
                    AppUser = await _userManager.FindByEmailAsync(_httpContextAccessor.HttpContext.User.Identity.Name),
                    Shop    = shop
                };

                _easyShopContext.RustCategories.Add(newCategory);
                await _easyShopContext.SaveChangesAsync();

                _logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
                                       userForLog.UserName,
                                       userForLog.Id,
                                       _httpContextAccessor.HttpContext.Request.GetRawTarget(),
                                       $"Description was successfully created. CategoryId: {newCategory.Id}");

                return(newCategory, RustEditCategoryResult.Created);
            }

            var category = GetCategoryById(Guid.Parse(model.RustCategoryEditViewModel.Category.Id));

            if (category is null)
            {
                return(null, RustEditCategoryResult.Failed);
            }

            category.Index = model.RustCategoryEditViewModel.Category.Index;
            category.Name  = model.RustCategoryEditViewModel.Category.Name;

            _easyShopContext.RustCategories.Update(category);
            await _easyShopContext.SaveChangesAsync();

            _logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
                                   userForLog.UserName,
                                   userForLog.Id,
                                   _httpContextAccessor.HttpContext.Request.GetRawTarget(),
                                   $"Description was successfully updated. CategoryId: {category.Id}");

            return(category, RustEditCategoryResult.Success);
        }
Example #3
0
        public ActionResult GetItemYaml(string id)
        {
            Assert.ArgumentNotNullOrEmpty(id, "id");
            using (var stream = new MemoryStream())
            {
                _yamlSerializationService.WriteSerializedItem(_sitecore.GetItemData(Guid.Parse(id)), stream);
                stream.Seek(0, SeekOrigin.Begin);

                using (var reader = new StreamReader(stream))
                {
                    return(Content(reader.ReadToEnd()));
                }
            }
        }
Example #4
0
        public async Task <Result> Handle(DeleteTicketCommand request, CancellationToken cancellationToken)
        {
            var ticket =
                await _ticketRepository.GetAsync(x => x.IsDeleted == false && (x.Id == request.Id || x.Children.Any(x => x.Id == request.Id)), cancellationToken);

            if (ticket is null)
            {
                return(Result.Failed(new NotFoundObjectResult(new ApiMessage(ResponseMessage.TicketNotFound))));
            }

            if (_currentUserService.RoleName != Role.Admin && ticket.User.Id != Guid.Parse(_currentUserService.UserId))
            {
                return(Result.Failed(new BadRequestObjectResult(new ApiMessage(ResponseMessage.DeleteNotAllowed))));
            }


            ticket.IsDeleted = true;

            await _ticketRepository.UpdateAsync(ticket);

            return(Result.SuccessFul());
        }
Example #5
0
        public async Task <Shop> UpdateShopAsync(RustShopEditMainSettingsViewModel model)
        {
            var shop = GetShopById(Guid.Parse(model.Id));

            if (shop is null)
            {
                return(null);
            }

            shop.ShopName     = model.ShopName;
            shop.ShopTitle    = model.ShopTitle;
            shop.StartBalance = model.StartBalance;

            var userForLog = await _userManager.FindByEmailAsync(_httpContextAccessor.HttpContext.User.Identity.Name);

            try
            {
                _easyShopContext.Shops.Update(shop);
                await _easyShopContext.SaveChangesAsync();

                _logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
                                       userForLog.UserName,
                                       userForLog.Id,
                                       _httpContextAccessor.HttpContext.Request.GetRawTarget(),
                                       $"Shop has been successfully updated! ShopId: {shop.Id}");

                return(shop);
            }
            catch (Exception e)
            {
                _logger.LogError("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
                                 userForLog.UserName,
                                 userForLog.Id,
                                 _httpContextAccessor.HttpContext.Request.GetRawTarget(),
                                 $"Error on updating shop. Error message: {e.Message}; Inner exception: {e.InnerException?.Message}; Stacktrace: {e.StackTrace};");

                return(null);
            }
        }
Example #6
0
        public async Task <RustEditProductResult> UpdateRustProductAsync(RustShopViewModel model)
        {
            var shop    = GetShopById(Guid.Parse(model.Id));
            var product =
                _easyShopContext.RustUserItems.FirstOrDefault(x => x.Id == Guid.Parse(model.RustProductEditViewModel.Id));

            var userForLog = await _userManager.FindByEmailAsync(_httpContextAccessor.HttpContext.User.Identity.Name);

            if (shop is null || product is null)
            {
                return(RustEditProductResult.NotFound);
            }

            if (!model.RustProductEditViewModel.ShowInShop)
            {
                product.ShowInShop = false;

                _easyShopContext.RustUserItems.Update(product);
                await _easyShopContext.SaveChangesAsync();

                _logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
                                       userForLog.UserName,
                                       userForLog.Id,
                                       _httpContextAccessor.HttpContext.Request.GetRawTarget(),
                                       $"Rust product was successfully updated. ItemId: {product.Id}");

                return(RustEditProductResult.Success);
            }

            product.ShowInShop    = true;
            product.Name          = model.RustProductEditViewModel.Name;
            product.Description   = model.RustProductEditViewModel.Description;
            product.Price         = model.RustProductEditViewModel.Price;
            product.Discount      = model.RustProductEditViewModel.Discount;
            product.ItemsPerStack = model.RustProductEditViewModel.Amount;
            product.Index         = model.RustProductEditViewModel.Index;

            if (model.RustProductEditViewModel.BlockedTill != null)
            {
                var dateFromModel   = model.RustProductEditViewModel.BlockedTill.Split('/');
                var blockedTillDate = new DateTime(int.Parse(dateFromModel[2]), int.Parse(dateFromModel[0]), int.Parse(dateFromModel[1]));

                long blockedTillTicks = blockedTillDate.Ticks;
                long currentMoment    = DateTime.Now.Ticks;

                if (blockedTillTicks - currentMoment < 1)
                {
                    return(RustEditProductResult.DateHaveToBeBiggerThanCurrentMoment);
                }

                product.BlockedTill = blockedTillDate;
            }

            if (model.RustProductEditViewModel.NewCategoryId != null)
            {
                product.RustCategory = GetCategoryById(Guid.Parse(model.RustProductEditViewModel.NewCategoryId));
            }

            _easyShopContext.RustUserItems.Update(product);
            await _easyShopContext.SaveChangesAsync();

            _logger.LogInformation("UserName: {0} | UserId: {1} | Request: {2} | Message: {3}",
                                   userForLog.UserName,
                                   userForLog.Id,
                                   _httpContextAccessor.HttpContext.Request.GetRawTarget(),
                                   $"Rust product was successfully updated. ItemId: {product.Id}");

            return(RustEditProductResult.Success);
        }
Example #7
0
        public Shop GetCurrentRequestShopInRustStore()
        {
            var tenantInfo = _httpContextAccessor.HttpContext.GetMultiTenantContext().TenantInfo;

            return(_easyShopContext.Shops.First(x => x.Id == Guid.Parse(tenantInfo.Id)));
        }