Exemplo n.º 1
0
 public void RemoveControls(Guid[] ids)
 {
     var controlsToRemove = Controls.Where(control => ids.Contains(control.Id)).ToArray();
     foreach (var control in controlsToRemove)
     {
         Controls.Remove(control);
     }
 }
 public static List<ISearchHandlerEx> GetHandlersExForProducts(Guid[] productIDs)
 {
     lock (handlers)
     {
         return handlers
             .Where(h => productIDs.Contains(h.ProductID) || h.ProductID.Equals(Guid.Empty))
             .ToList();
     }
 }
 public IList<RepositoryModel> GetPermittedRepositories(Guid userId, Guid[] userTeamsId)
 {
     if (userId == Guid.Empty) throw new ArgumentException("Do not pass invalid userId", "userId");
     return GetAllRepositories().Where(repo =>
         repo.Users.Any(user => user.Id == userId) ||
         repo.Administrators.Any(admin => admin.Id == userId) ||
         repo.Teams.Any(team => userTeamsId.Contains(team.Id)) ||
         repo.AnonymousAccess).ToList();
 }
Exemplo n.º 4
0
 public void SendMessage(string subject, string body, Guid authorID, Guid[] recipientIDs)
 {
     var recipients = _repository.FindAllBy<Traveler>(t => recipientIDs.Contains(t.TravelerID));
     if (recipients == null || recipients.Count() != recipientIDs.Count()) throw new TravelerNotFoundException();
     Traveler author = _repository.FindBy<Traveler>(r => r.TravelerID == authorID);
     if (author == null) throw new TravelerNotFoundException();
     Message message = MessageFactory.CreateMessageFrom(subject, body, author, recipients);
     _repository.Add<Message>(message);
     _repository.Commit();
 }
Exemplo n.º 5
0
        public void TestLinqArrayContains()
        {
            var app = SetupHelper.BooksApp;
              var session = app.OpenSession();

              var bookOrders = session.EntitySet<IBookOrder>();
              //Note: for debugging use table that is not fully cached, so we use IBookOrder entity

              // Test retrieving orders by Id-in-list
              var someOrders = bookOrders.Take(2).ToList();
              var someOrderIds = someOrders.Select(o => o.Id).ToArray();
              var qSomeOrders = from bo in bookOrders
                        where someOrderIds.Contains(bo.Id)
                        select bo;
              var someOrders2 = qSomeOrders.ToList();
              var cmd = session.GetLastCommand(); //just for debugging
              Assert.AreEqual(someOrderIds.Length, someOrders2.Count, "Test Array.Contains failed: order counts do not match.");

              // Try again with a single Id
              var arrOneId = new Guid[] { someOrderIds[0] };
              var qOrders = from bo in bookOrders
                    where arrOneId.Contains(bo.Id)
                    select bo;
              var orders = qOrders.ToList();
              Assert.AreEqual(1, orders.Count, "Test Array.Contains with one Id failed: order counts do not match.");

              // Again with empty list
              var arrEmpty = new Guid[] {};
              var qNoBooks = from b in session.EntitySet<IBook>()
                     where arrEmpty.Contains(b.Id)
                    select b;
              var noBooks = qNoBooks.ToList();
              cmd = session.GetLastCommand();
              Assert.AreEqual(0, noBooks.Count, "Test Array.Contains with empty array failed, expected 0 entities");

              // Again with list, not array
              var orderIdsList = someOrderIds.ToList();
              qOrders = from bo in bookOrders
                where orderIdsList.Contains(bo.Id)
                select bo;
              orders = qOrders.ToList();
              Assert.AreEqual(orderIdsList.Count, orders.Count, "Test constList.Contains, repeated query failed: order counts do not match.");

              // Test intList.Contains()
              var userTypes = new UserType[] { UserType.Customer, UserType.Author };
              var qOrders2 = from bo in bookOrders
                    where userTypes.Contains(bo.User.Type)
                    select bo;
              var orders2 = qOrders2.ToList();
              Assert.IsTrue(orders2.Count > 0, "No orders by type found.");
        }
Exemplo n.º 6
0
        //删除文档
        public static void Delete(Guid[] ids)
        {
            using (var context = new DataModelDataContext())
            {
                var objs =
                    (from item in context.Documents where ids.Contains(item.Id) select item).ToList();

                foreach (Document item in objs)
                {
                    context.Documents.DeleteOnSubmit(item);
                }

                context.SubmitChanges();
            }
        }
Exemplo n.º 7
0
        /// <summary></summary>
        /// <param name="descendant"></param>
        /// <returns>A list of all ancestor timelines which also includes the current timeline.</returns>
        public static List<Guid> Ancestors(this Timeline descendant)
        {
            List<Guid> rv = new List<Guid>();

            Timeline timeline = descendant;
            Guid[] searchTerm;

            using (Storage storage = new Storage())
            {
                while (timeline != null)
                {
                    rv.Add(timeline.Id);
                    searchTerm = new Guid[] { timeline.Id };
                    timeline = storage.Timelines.Where(t => t.ChildTimelines.Any(ct => searchTerm.Contains(ct.Id))).FirstOrDefault(); // get parent if exists
                }
            }

            return rv;
        }
            private static IMembershipService GetMembershipService(Guid[] keys) {

                var users = GetDummyUsers(keys);
                var mockMemSrv = ServicesMockHelper
                    .GetInitialMembershipServiceMock();

                mockMemSrv.Setup(ms => ms.GetUser(
                        It.Is<Guid>(
                            key => keys.Contains(key)
                        )
                    )
                ).Returns<Guid>(key =>
                    users.FirstOrDefault(x =>
                        x.User.Key == key
                    )
                );

                mockMemSrv.Setup(ms => ms.UpdateUser(
                        It.IsAny<User>(), It.IsAny<string>(), It.IsAny<string>()
                    )
                ).Returns<User, string, string>(
                    (user, username, email) => {

                        var roles = users
                            .FirstOrDefault(
                                x => x.User.Name.Equals(user.Name, StringComparison.OrdinalIgnoreCase)).Roles;

                        user.Name = username;
                        user.Email = email;
                        return new UserWithRoles {
                            User = user,
                            Roles = roles
                        };
                    }
                );

                return mockMemSrv.Object;
            }
            private static IMembershipService GetMembershipService(Guid[] keys) {

                var users = GetDummyUsers(keys);
                var mockMemSrv = ServicesMockHelper
                    .GetInitialMembershipServiceMock();

                mockMemSrv.Setup(ms => ms.GetUser(
                        It.Is<Guid>(
                            key => keys.Contains(key)
                        )
                    )
                ).Returns<Guid>(key => 
                    users.FirstOrDefault(x =>
                        x.User.Key == key
                    )
                );

                return mockMemSrv.Object;
            }
 public IEnumerable<ControlEntry> Get(Guid[] controls)
 {
     return Dic.Values.SelectMany(l => l.Where(c => controls.Contains(c.Id)));
 }
        public ActionResult CardDatabaseDifferences(bool? commit, Guid[] except)
        {
            var cardMembers = CardDatabaseService.GetEmergencyWorkers();
              var cardMembersDict = cardMembers.ToDictionary(f => f.PK, f => f);

              var dbMembers = this.db.Members
              .Where(f => f.WacLevel > WacLevel.None && f.Memberships.Any(g => g.EndTime == null && g.Status.IsActive) && f.ExternalKey1 != null)
              .OrderBy(f => f.LastName).ThenBy(f => f.FirstName).ToList();

              StringBuilder builder = new StringBuilder();

              var d = 0;

              while (d < dbMembers.Count)
              {
            if (cardMembersDict.ContainsKey(dbMembers[d].ExternalKey1.Value))
            {
              var cardMember = cardMembersDict[dbMembers[d].ExternalKey1.Value];

              string matchText = "";
              if (cardMember.IdentityCode != dbMembers[d].DEM)
            matchText += string.Format(", KCSO DEM={0} KCSARA DEM={1}", cardMember.IdentityCode, dbMembers[d].DEM);
              if (cardMember.Rank != dbMembers[d].WacLevel.ToString())
            matchText += string.Format(", KCSO Card={0} KCSARA Card={1}", cardMember.Rank, dbMembers[d].WacLevel.ToString());
              if (matchText.Length > 0)
            builder.AppendFormat("<b>{0}</b> has differences{1}<br/>", dbMembers[d].ReverseName, matchText);

              if (!cardMember.LastName.Equals(dbMembers[d].LastName, StringComparison.OrdinalIgnoreCase) || !cardMember.FirstName.Equals(dbMembers[d].FirstName, StringComparison.OrdinalIgnoreCase))
            builder.AppendFormat("<span style=\"color:#cccccc\">KCSARA member {0} in KCSO database as {1}, {2}</span><br/>", dbMembers[d].ReverseName, cardMember.LastName, cardMember.FirstName);

              cardMembersDict.Remove(dbMembers[d].ExternalKey1.Value);
              dbMembers.RemoveAt(d);
            }
            else
            {
              builder.AppendFormat("<b><a href=\"{1}\">{0}</a></b> was linked to a card database record that no longer exists<br/>", dbMembers[d].ReverseName, Url.Action("Detail", new { id = dbMembers[d].Id }));
              d++;
            }
              }

              cardMembers = cardMembersDict.Values.OrderBy(f => f.LastName).ThenBy(f => f.FirstName).ToList();
              dbMembers = this.db.Members.Where(f => f.WacLevel > WacLevel.None && f.Memberships.Any(g => g.EndTime == null && g.Status.IsActive) && f.ExternalKey1 == null)
              .OrderBy(f => f.LastName).ThenBy(f => f.FirstName).ToList();

              d = 0;
              while (d < dbMembers.Count)
              {
            var dbMember = dbMembers[d];

            var matches = cardMembers.Where(f => f.LastName.Equals(dbMember.LastName, StringComparison.OrdinalIgnoreCase) && f.FirstName.Equals(dbMember.FirstName, StringComparison.OrdinalIgnoreCase));
            if (matches.Count() > 1)
            {
              matches = cardMembers.Where(f => f.IdentityCode == dbMember.DEM && f.LastName.Equals(dbMember.LastName, StringComparison.OrdinalIgnoreCase) && f.FirstName.Equals(dbMember.FirstName, StringComparison.OrdinalIgnoreCase));
            }
            else if (matches.Count() == 0)
            {
              matches = cardMembers.Where(f => f.IdentityCode == dbMember.DEM && f.LastName.Equals(dbMember.LastName, StringComparison.OrdinalIgnoreCase));
            }

            if (matches.Count() == 0)
            {
              builder.AppendFormat("Can't find <b><a href=\"{1}\">{0}</a></b> in card database<br/>", dbMember.ReverseName, Url.Action("Detail", new { id = dbMember.Id }));
              d++;
            }
            else if (matches.Count() == 1)
            {
              var cardMember = matches.First();

              builder.AppendFormat("New linked member: <b>{0}, {1}</b> ({2}) - {3}  <i><a href=\"{5}\">{4}</a> [{6}]</i><br/>", cardMember.LastName, cardMember.FirstName, cardMember.IdentityCode, cardMember.Rank, dbMember.ReverseName, Url.Action("Detail", new { id = dbMember.Id }), cardMember.PK);

              string matchText = "";
              if (cardMember.IdentityCode != dbMember.DEM)
            matchText += string.Format(", KCSO DEM={0} KCSARA DEM={1}", cardMember.IdentityCode, dbMember.DEM);
              if (cardMember.Rank != dbMember.WacLevel.ToString())
            matchText += string.Format(", KCSO Card={0} KCSARA Card={1}", cardMember.Rank, dbMember.WacLevel.ToString());

              if (matchText.Length > 0)
            builder.AppendFormat("<b>{0}</b> has differences{1}<br/>", dbMember.ReverseName, matchText);

              if (except == null || !except.Contains(dbMember.Id))
              {
            dbMember.ExternalKey1 = cardMember.PK;
              }
              else
              {
            builder.AppendFormat("Skipped linking by request<br/>");
              }

              cardMembers.Remove(cardMember);
              dbMembers.RemoveAt(d);
            }
            else
            {
              builder.AppendFormat("Multiple card records with name {0} and DEM {1}<br/>", dbMember.FullName, dbMember.DEM);
              dbMembers.RemoveAt(d);
              cardMembers.RemoveAll(f => f.LastName.Equals(dbMember.LastName, StringComparison.OrdinalIgnoreCase) &&
              f.FirstName.Equals(dbMember.FirstName, StringComparison.OrdinalIgnoreCase) &&
              f.IdentityCode == dbMember.DEM);
            }
              }

              foreach (var cardMember in cardMembers)
              {
            var matches = this.db.Members.Where(f => f.ExternalKey1 == cardMember.PK);

            if (matches.Count() < 1)
            {
              matches = this.db.Members.Where(f => f.LastName == cardMember.LastName && f.FirstName == cardMember.FirstName);
            }

            if (matches.Count() > 1)
            {
              matches = this.db.Members.Where(f => f.DEM == cardMember.IdentityCode && f.LastName == cardMember.LastName && f.FirstName == cardMember.FirstName);
            }
            else if (matches.Count() == 0)
            {
              matches = this.db.Members.Where(f => f.DEM == cardMember.IdentityCode && f.LastName == cardMember.LastName);
            }

            if (matches.Count() == 0)
            {
              builder.AppendFormat("{0}, {1} ({2}) not found in KCSARA database. [card id {3}]<br/>", cardMember.LastName, cardMember.FirstName, cardMember.IdentityCode, cardMember.PK);
              if (cardMember.IdentityCode.Contains("D"))
              {
            builder.AppendFormat("Should change Rank for {0}, {1} to 'Canine'<br/>", cardMember.LastName, cardMember.FirstName);
              }
            }
            else if (matches.Count() == 1)
            {
              builder.AppendFormat("<a href=\"{2}\">{0}, {1}</a> is no longer mission active with KCSARA<br/>", cardMember.LastName, cardMember.FirstName, Url.Action("Detail", new { id = matches.First().Id }));
            }
            else
            {
              builder.AppendFormat("{0}, {1} has multiple matches in the KCSARA database.<br/>", cardMember.LastName, cardMember.FirstName);
            }

              }

              if (commit ?? false) this.db.SaveChanges();

              return Content(builder.ToString());
        }
Exemplo n.º 12
0
        public ActionResult RequestFeedback(Guid id, string message, Guid[] instructors)
        {
            var experience =
                RepositoryFactory.ExperienceRepository.Queryable.SingleOrDefault(
                    x => x.Id == id && x.Creator.Identifier == CurrentUser.Identity.Name);

            if (experience == null)
            {
                return new HttpNotFoundResult("Could not find the requested experience");
            }

            var instructorsToNotify =
                RepositoryFactory.InstructorRepository.Queryable.Where(x => instructors.Contains(x.Id)).ToList();

            foreach (var instructor in instructorsToNotify)
            {
                experience.AddFeedbackRequest(new FeedbackRequest {Message = message, Instructor = instructor});
            }

            if (experience.InstructorViewable == false)
            {
                experience.InstructorViewable = true;
            }

            RepositoryFactory.ExperienceRepository.EnsurePersistent(experience);

            Message = string.Format("Feedback Requests sent successfully");

            return RedirectToAction("ViewExperience", "Student", new {id});
        }
        private void UpdateSubOrganizationsStatus(MembershipDataContext ctx, Guid[] parentOrganizationIds, OrganizationStatus status)
        {
            var q = from org in ctx.Organizations
                    where org.ParentOrganizationId.HasValue
                        && parentOrganizationIds.Contains(org.ParentOrganizationId.Value)
                        && org.Status != status
                    select org;

            if (q.Count() == 0) return;

            foreach (Organization organization in q.AsEnumerable())
            {
                organization.Status = status;
                base.RemoveCache(organization.OrganizationId);
            }

            UpdateSubOrganizationsStatus(ctx, q.Select(org => org.OrganizationId).ToArray(), status);
        }
Exemplo n.º 14
0
        /// <summary>
        /// Suggests description instances from the defined in Suggester sources based on one or more semantic objects
        /// </summary>
        /// <param name="semanticObjects">RDF based concrete semantic object</param>
        /// <param name="sourceFilter">if Null all sources are used, if set only those set are processed</param>
        /// <returns>Returns collection of suggested description objects (such as keywords, RDF statements, etc.)</returns>
        public List<ISuggestionInstance> GetSuggestions(ISemanticObject[] semanticObjects, Guid[] sourceFilter = null)
        {
            Dictionary<string, Tuple<ISuggestionInstance, double>> CombinedCollection = new Dictionary<string, Tuple<ISuggestionInstance, double>>();
            double maxRelevanceSum = 0;
            double minRelevanceValue = double.MaxValue;
            const string combinedSourceName = "Multiple sources";
            Guid combinedGuid = Guid.NewGuid();

            foreach (var nextSource in this.sources)
            {
                if (sourceFilter == null || sourceFilter.Contains(nextSource.Guid))
                {
                    foreach (var nextResult in nextSource.GetSuggestions(semanticObjects))
                    {
                        double combinedrelevance;
                        if (CombinedCollection.ContainsKey(nextResult.GetTextValue()))
                        {
                            var oldvalue = CombinedCollection[nextResult.GetTextValue()];
                            combinedrelevance = oldvalue.Item2 + nextResult.Relevance;

                            // HACK - think how this should be when RDF suggestions sources implemented. Should we flatter them like this or do something else.
                            var combinedResult = new StringKeywordSuggestion(nextResult.GetTextValue(), combinedGuid, combinedSourceName);
                            nextResult.Rank = nextResult.Rank + oldvalue.Item1.Rank;
                            CombinedCollection[nextResult.GetTextValue()] = new Tuple<ISuggestionInstance, double>(combinedResult, combinedrelevance);
                        }
                        else
                        {
                            combinedrelevance = nextResult.Relevance;
                            CombinedCollection.Add(nextResult.GetTextValue(), new Tuple<ISuggestionInstance, double>(nextResult, combinedrelevance));
                        }

                        if (combinedrelevance > maxRelevanceSum)
                        {
                            maxRelevanceSum = combinedrelevance;
                        }

                        if (combinedrelevance < minRelevanceValue)
                        {
                            minRelevanceValue = combinedrelevance;
                        }
                    }
                }
            }

            // now normalize relevance
            var readyList = new List<ISuggestionInstance>();
            foreach (var nextSuggestion in CombinedCollection)
            {
                // map 0...max to 0..100;
                double newrelevance = (maxRelevanceSum * nextSuggestion.Value.Item2 == 0) ? 0 : 100 / maxRelevanceSum * nextSuggestion.Value.Item2;
                var nextsuggestion = nextSuggestion.Value.Item1;
                nextsuggestion.Relevance = newrelevance;
                readyList.Add(nextsuggestion);
            }

            readyList.Sort(delegate (ISuggestionInstance x, ISuggestionInstance y)
            {
                return y.Relevance.CompareTo(x.Relevance); // descending sort
            });
            return readyList;
        }
Exemplo n.º 15
0
 public SearchResult LoadSetting(Guid[] checksum)
 {
     var sr = new SearchResult();
     var db = new x360ceModelContainer();
     sr.PadSettings = db.PadSettings.Where(x => checksum.Contains(x.PadSettingChecksum)).ToArray();
     db.Dispose();
     db = null;
     return sr;
 }
Exemplo n.º 16
0
        /// <summary>
        /// 删除数据实体
        /// </summary>
        /// <param name="ids">要删除的数据实体主键列表</param>
        /// <returns>成功返回 true;否则返回 false。</returns>
        public virtual WebApiResult Delete(Guid[] ids)
        {
            var result = new WebApiResult();

            #region 删除
            var entities = from item in DataContext.Basic_Announcement
                           where ids.Contains(item.Id)
                           select item;
            DataContext.Basic_Announcement.RemoveRange(entities);
            DataContext.SaveChanges();
            #endregion

            return result;
        }
Exemplo n.º 17
0
        /// <summary>
        /// Updates a specified menu owned by the current user.
        /// </summary>
        /// <param name="menuId">The Menu ID to update, or null to update the Favorites menu.</param>
        /// <param name="recipesAdd">A list of recipe IDs to add to the menu.  Duplicates will be ignored.</param>
        /// <param name="recipesRemove">A list of recipe IDs to remove from the menu.</param>
        /// <param name="recipesMove">A list of items to move from this menu to another menu.</param>
        /// <param name="clear">If true, all recipes will be removed from this menu.</param>
        /// <param name="newName">An optional new name for this menu.  Note, the favorites menu cannot be renamed.</param>
        /// <returns></returns>
        public MenuResult UpdateMenu(Guid? menuId, Guid[] recipesAdd, Guid[] recipesRemove, MenuMove[] recipesMove, bool clear, string newName = null)
        {
            var ret = new MenuResult();
             ret.IsMenuUpdated = true; // TODO: Verify actual changes were made before setting MenuUpdated to true

             Menus dbMenu = null;
             if (menuId.HasValue)
             {
            dbMenu = store.Menus.SingleOrDefault(p => p.MenuId == menuId);
            if (dbMenu == null)
               throw new MenuNotFoundException();

            if (dbMenu.UserId != Identity.UserId) // User does not have access to modify this menu
               throw new UserDoesNotOwnMenuException();
             }

             var dbFavorites = store.Favorites
            .Where(p => p.MenuId == menuId)
            .ToList();

             if (!string.IsNullOrWhiteSpace(newName) && dbMenu != null) // Rename menu
            dbMenu.Title = newName.Trim();

             if (recipesAdd.Any()) // Add recipes to menu
             {
            var existing = dbFavorites.Select(f => f.RecipeId);
            recipesAdd = recipesAdd.Except(existing).ToArray(); //Remove dupes

            foreach (var rid in recipesAdd)
            {
               var fav = new Favorites
               {
                  FavoriteId = Guid.NewGuid(),
                  UserId = Identity.UserId,
                  RecipeId = rid,
                  MenuId = menuId
               };

               store.Favorites.Add(fav);
            }
             }

             if (recipesRemove.Any()) // Remove recipes from menu
             {
            var toDelete = (from r in dbFavorites where recipesRemove.Contains(r.RecipeId) select r);
            toDelete.ForEach(r => store.Favorites.Remove(r));
             }

             if (clear) // Remove every recipe from menu
             {
            store.Favorites.RemoveAll(dbFavorites.Contains);
             }

             if (recipesMove.Any()) // Move items to another menu
             {
            foreach (var moveAction in recipesMove)
            {
               Menus dbTarget = null;
               if (moveAction.TargetMenu.HasValue)
               {
                  dbTarget = store.Menus
                     .Where(p => p.UserId == Identity.UserId)
                     .SingleOrDefault(p => p.MenuId == moveAction.TargetMenu);

                  if (dbTarget == null)
                     throw new MenuNotFoundException(moveAction.TargetMenu.Value);
               }

               var rToMove = (moveAction.AllMoved
                  ? dbFavorites
                  : dbFavorites.Where(r => moveAction.RecipesToMove.Contains(r.RecipeId)));

               rToMove.ForEach(a => a.MenuId = dbTarget != null ? (Guid?) dbTarget.MenuId : null);
            }
             }

             return ret;
        }
Exemplo n.º 18
0
        /// <summary>
        /// Reads full information for one or more recipes in the database.
        /// </summary>
        /// <param name="recipeIds">An array containing recipe IDs to load.</param>
        /// <param name="options">Indicates which properties to load.  Use ReadRecipeOptions.None to only load base recipe data.</param>
        /// <returns></returns>
        public Recipe[] ReadRecipes(Guid[] recipeIds, ReadRecipeOptions options)
        {
            var recipes = store.Recipes.Where(r => recipeIds.Contains(r.RecipeId)).ToList();

             if (!recipes.Any())
            throw new RecipeNotFoundException();

             var riIndex = store.GetIndexedRecipeIngredients();
             var ingIndex = store.GetIndexedIngredients();
             var formIndex = store.GetIndexedIngredientForms();
             var rmetaIndex = store.GetIndexedRecipeMetadata();
             var imetaIndex = store.GetIndexedIngredientMetadata();

             var ret = new List<Recipe>();
             foreach (var r in recipes)
             {
            var recipe = new Recipe
            {
               Id = r.RecipeId,
               Title = r.Title,
               Description = r.Description,
               DateEntered = r.DateEntered,
               ImageUrl = r.ImageUrl,
               ServingSize = r.ServingSize,
               PrepTime = r.PrepTime,
               CookTime = r.CookTime,
               Credit = r.Credit,
               CreditUrl = r.CreditUrl,
               AvgRating = r.Rating
            };

            if (options.ReturnMethod)
               recipe.Method = r.Steps;

            if (options.ReturnUserRating)
            {
               var userRating = store.RecipeRatings.SingleOrDefault(ur => (ur.RecipeId == r.RecipeId && ur.UserId == Identity.UserId));
               recipe.UserRating = userRating != null ? (Rating) userRating.Rating : Rating.None;
            }

            recipe.Ingredients = riIndex[r.RecipeId].Select(i => new IngredientUsage
            {
               Amount = i.Qty.HasValue ? new Amount(i.Qty.Value, i.Unit) : null,
               PrepNote = i.PrepNote,
               Section = i.Section,
               Form = i.IngredientFormId.HasValue ? IngredientForms.ToIngredientForm(formIndex[i.IngredientFormId.Value]) : null,
               Ingredient = Data.DTO.Ingredients.ToIngredient(ingIndex[i.IngredientId], imetaIndex[i.IngredientId])
            }).ToArray();

            recipe.Tags = RecipeMetadata.ToRecipeTags(rmetaIndex[r.RecipeId]);
            ret.Add(recipe);
             }

             return ret.ToArray();
        }
Exemplo n.º 19
0
        ShoppingListResult UpdateShoppingList(Guid? listId, Guid[] toRemove, IEnumerable<ShoppingListModification> toModify, IEnumerable<IShoppingListSource> toAdd, string newName = null)
        {
            // Deletes
             if (toRemove.Any())
             {
            var dbDeletes = store.ShoppingListItems
               .Where(p => p.UserId == Identity.UserId)
               .Where(p => p.ShoppingListId == listId)
               .Where(p => toRemove.Contains(p.ItemId));

            store.ShoppingListItems.RemoveAll(dbDeletes.Contains);
             }

             // Updates
             Guid? shoppingListId = null;
             ShoppingLists dbList = null;
             List<ShoppingListItems> dbItems = null;
             if (listId.HasValue)
             {
            dbList = store.ShoppingLists
               .Where(p => p.UserId == Identity.UserId)
               .SingleOrDefault(p => p.ShoppingListId == listId);

            if (dbList == null)
               throw new ShoppingListNotFoundException();

            dbItems = store.ShoppingListItems
               .Where(p => p.UserId == Identity.UserId)
               .Where(p => p.ShoppingListId.Equals(dbList.ShoppingListId))
               .ToList();

            if (!string.IsNullOrWhiteSpace(newName))
               dbList.Title = newName;

            shoppingListId = dbList.ShoppingListId;
             }
             else
             {
            dbItems = store.ShoppingListItems
               .Where(p => p.UserId == Identity.UserId)
               .Where(p => p.ShoppingListId == null)
               .ToList();
             }

             toModify.ForEach(item =>
             {
            var dbItem = store.ShoppingListItems.SingleOrDefault(p => p.ItemId == item.ModifiedItemId);
            if (dbItem == null) return;

            if (item.CrossOut.HasValue) dbItem.CrossedOut = item.CrossOut.Value;
            if (item.NewAmount != null)
            {
               dbItem.Qty = item.NewAmount.SizeHigh;
               dbItem.Unit = item.NewAmount.Unit;
            }
             });

             toAdd.ForEach(item =>
             {
            var source = item.GetItem();

            if (source.Ingredient == null && !string.IsNullOrWhiteSpace(source.Raw)) // Raw shopping list item
            {
               if (!dbItems.Any(i => source.Raw.Equals(i.Raw, StringComparison.OrdinalIgnoreCase))) // Add it
               {
                  store.ShoppingListItems.Add(new ShoppingListItems
                  {
                     ItemId = Guid.NewGuid(),
                     ShoppingListId = shoppingListId,
                     UserId = Identity.UserId,
                     Raw = source.Raw
                  });
               }

               return;
            }

            if (source.Ingredient != null && source.Amount == null) // Raw ingredient without any amount
            {
               var existingItem = dbItems.FirstOrDefault(i => i.IngredientId.HasValue && i.IngredientId.Value == source.Ingredient.Id);

               if (existingItem == null) // Add it
               {
                  store.ShoppingListItems.Add(new ShoppingListItems
                  {
                     ItemId = Guid.NewGuid(),
                     ShoppingListId = shoppingListId,
                     UserId = Identity.UserId,
                     IngredientId = source.Ingredient.Id
                  });
               }
               else // Clear out existing amount
               {
                  existingItem.Qty = null;
                  existingItem.Unit = null;
               }
            }

            if (source.Ingredient != null && source.Amount != null) // Ingredient with amount, aggregate if necessary
            {
               var existingItem = dbItems.FirstOrDefault(i => i.IngredientId.HasValue && i.IngredientId.Value == source.Ingredient.Id);

               if (existingItem == null) // Add it
               {
                  store.ShoppingListItems.Add(new ShoppingListItems
                  {
                     ItemId = Guid.NewGuid(),
                     ShoppingListId = shoppingListId,
                     UserId = Identity.UserId,
                     IngredientId = source.Ingredient.Id,
                     Qty = source.Amount != null ? (float?) source.Amount.SizeHigh : null,
                     Unit = source.Amount != null ? (Units?) source.Amount.Unit : null
                  });
               }
               else if (existingItem.Qty.HasValue) // Add to total
               {
                  existingItem.Qty += source.Amount.SizeHigh;
               }
            }
             });

             // Load full list to return
             var indexIngredients = store.GetIndexedIngredients();
             var indexRecipes = store.GetIndexedRecipes();

             var items = store.ShoppingListItems
            .Where(p => p.UserId == Identity.UserId)
            .Where(l => l.ShoppingListId == shoppingListId).Select(item =>
               new ShoppingListItem(item.ItemId)
               {
                  Raw = item.Raw,
                  Ingredient = item.IngredientId.HasValue ? Data.DTO.Ingredients.ToIngredient(indexIngredients[item.IngredientId.Value]) : null,
                  Recipe = item.RecipeId.HasValue ? Data.DTO.Recipes.ToRecipeBrief(indexRecipes[item.RecipeId.Value]) : null,
                  CrossedOut = item.CrossedOut,
                  Amount = (item.Qty.HasValue && item.Unit.HasValue) ? new Amount(item.Qty.Value, item.Unit.Value) : null
               });

             return new ShoppingListResult
             {
            List = new ShoppingList(shoppingListId, dbList != null ? dbList.Title : "", items)
             };
        }
Exemplo n.º 20
0
 /// <summary>
 /// Get file infos by identifiers
 /// </summary>
 /// <param name="identifiers">File info identifiers</param>
 /// <returns>Files info</returns>
 public FileExecutionResults GetRange(Guid[] identifiers)
 {
     UpdateSessionCulture();
     using (var logSession = Helpers.Log.Session($"{GetType()}.{System.Reflection.MethodBase.GetCurrentMethod().Name}()", VerboseLog, RaiseLog))
         try
         {
             using (var rep = GetNewRepository(logSession))
             {
                 var res = rep.Get<RoyaltyRepository.Models.File>(f => identifiers.Contains(f.FileUID))
                     .ToArray()
                     .Select(f => Mapper.Map<Model.File>(f))
                     .ToArray();
                 return new FileExecutionResults(res);
             }
         }
         catch (Exception ex)
         {
             ex.Data.Add(nameof(identifiers), identifiers.Concat(i => i.ToString("N"), ","));
             logSession.Enabled = true;
             logSession.Add(ex);
             return new FileExecutionResults(ex);
         }
 }
 public GuidExecutionResults RemoveImportQueueRecordRange(Guid[] identifiers)
 {
     UpdateSessionCulture();
     using (var logSession = Helpers.Log.Session($"{GetType()}.{System.Reflection.MethodBase.GetCurrentMethod().Name}()", VerboseLog, RaiseLog))
         try
         {
             using (var rep = GetNewRepository(logSession))
             {
                 logSession.Add($"Try to get account import queue records with ids = '{identifiers.Concat(i => i.ToString(), ",")}' from database...");
                 var itemsToRemove = rep.Get<RoyaltyRepository.Models.ImportQueueRecord>(a => identifiers.Contains(a.ImportQueueRecordUID)).ToArray();
                 logSession.Add($"Accounts import queue records found for remove: {itemsToRemove.Length}");
                 rep.RemoveRange(itemsToRemove);
                 rep.SaveChanges();
                 return new GuidExecutionResults(itemsToRemove.Select(i => i.ImportQueueRecordUID).ToArray());
             }
         }
         catch (Exception ex)
         {
             ex.Data.Add(nameof(identifiers), identifiers.Concat(i => i.ToString(),","));
             logSession.Enabled = true;
             logSession.Add(ex);
             return new GuidExecutionResults(ex);
         }
 }
Exemplo n.º 22
0
        public MenuResult UpdateMenu(AuthIdentity identity, Guid? menuId, Guid[] recipesAdd, Guid[] recipesRemove, MenuMove[] recipesMove, bool clear, string newName = null)
        {
            var ret = new MenuResult();
             ret.MenuUpdated = true; // TODO: Verify actual changes were made before setting MenuUpdated to true

             using (var session = GetSession())
             {
            using (var transaction = session.BeginTransaction())
            {
               Models.Menus dbMenu = null;
               IList<Favorites> dbRecipes = null;
               if (menuId.HasValue)
               {
                  dbMenu = session.QueryOver<Models.Menus>()
                     .Fetch(prop => prop.Recipes).Eager
                     .Where(p => p.MenuId == menuId)
                     .SingleOrDefault();

                  if (dbMenu == null)
                     throw new MenuNotFoundException();

                  if (dbMenu.UserId != identity.UserId) // User does not have access to modify this menu
                     throw new UserDoesNotOwnMenuException();

                  if (!String.IsNullOrWhiteSpace(newName) && dbMenu != null) // Rename menu
                     dbMenu.Title = newName.Trim();

                  dbRecipes = dbMenu.Recipes;
               }
               else
               {
                  dbRecipes = session.QueryOver<Favorites>()
                     .Where(p => p.UserId == identity.UserId)
                     .Where(p => p.Menu == null)
                     .List();
               }

               if (recipesAdd.Any()) // Add recipes to menu
               {
                  var existing = (from r in dbRecipes select r.Recipe.RecipeId);
                  recipesAdd = recipesAdd.Except(existing).ToArray(); //Remove dupes

                  foreach (var rid in recipesAdd)
                  {
                     var fav = new Favorites
                     {
                        UserId = identity.UserId,
                        Recipe = new Models.Recipes() {RecipeId = rid},
                        Menu = dbMenu
                     };

                     session.Save(fav);
                  }
               }

               if (recipesRemove.Any()) // Remove recipes from menu
               {
                  var toDelete = (from r in dbRecipes where recipesRemove.Contains(r.Recipe.RecipeId) select r);
                  toDelete.ForEach(session.Delete);
               }

               if (clear) // Remove every recipe from menu
               {
                  dbRecipes.ForEach(session.Delete);
               }

               if (recipesMove.Any()) // Move items to another menu
               {
                  foreach (var moveAction in recipesMove)
                  {
                     Models.Menus dbTarget = null;
                     if (moveAction.TargetMenu.HasValue)
                     {
                        dbTarget = session.QueryOver<Models.Menus>()
                           .Where(p => p.MenuId == moveAction.TargetMenu.Value)
                           .Where(p => p.UserId == identity.UserId)
                           .SingleOrDefault();

                        if (dbTarget == null)
                           throw new MenuNotFoundException(moveAction.TargetMenu.Value);
                     }

                     var rToMove = (moveAction.MoveAll
                        ? dbRecipes
                        : dbRecipes.Where(r => moveAction.RecipesToMove.Contains(r.Recipe.RecipeId)));

                     rToMove.ForEach(a => a.Menu = dbTarget);
                  }
               }

               transaction.Commit();
            }
             }

             return ret;
        }
Exemplo n.º 23
0
 /// <summary>
 /// Gets the list of uncommited uncomited allocations.
 /// </summary>
 /// <param name="ids">The ids.</param>
 /// <returns></returns>
 public List<DispatchAllocation> GetUncomitedAllocations(Guid[] ids)
 {
     return _unitOfWork.DispatchAllocationRepository.Get(p => ids.Contains(p.DispatchAllocationID)).ToList();
 }
Exemplo n.º 24
0
        /// <summary>
        /// 删除数据实体
        /// </summary>
        /// <param name="ids">要删除的数据实体主键列表</param>
        /// <returns>成功返回 true;否则返回 false。</returns>
        public virtual WebApiResult Delete(Guid[] ids)
        {
            var result = new WebApiResult();

            #region 删除
            var entities = from item in DataContext.Product_ProductDefinition
                           where ids.Contains(item.Id)
                           select item;
            DataContext.Product_ProductDefinition.RemoveRange(entities);
            DataContext.SaveChanges();
            #endregion

            return result;
        }
            private IMembershipService GetMembershipService(Guid[] keys) {

                var roles = GetDummyRoles(keys);
                var mockMemSrv = ServicesMockHelper
                    .GetInitialMembershipServiceMock();

                mockMemSrv.Setup(ms => ms.GetRole(
                        It.Is<Guid>(key =>
                            keys.Contains(key)
                        )
                    )
                ).Returns<Guid>(key => 
                    roles.FirstOrDefault(
                        role => role.Key == key
                    )
                );

                return mockMemSrv.Object;
            }
 public void RebuildPicture(AccountItem data, Guid[] pictureIds)
 {
     if (pictureIds != null && pictureIds.Length > 0)
     {
         var pics = this.AccountBookDataContext.PictureInfos.Where(p => pictureIds.Contains(p.PictureId) && p.AttachedId == data.AutoTokenId)
             .AsEnumerable();
         data.PicturesOutOfDatabase = pics.ToList();
     }
 }
Exemplo n.º 27
0
 private List<IFavorite> GetFavoritesInGroup(Guid[] favoritesInGroup)
 {
     return this.Favorites
         .Where(favorite => favoritesInGroup.Contains(favorite.Id))
         .ToList();
 }
        public void RebuildPeople(AccountItem data, Guid[] peopleAssociationIds)
        {
            if (peopleAssociationIds != null && peopleAssociationIds.Length > 0)
            {
                var peoples = this.AccountBookDataContext.PeopleAssociationDatas.Where(p => peopleAssociationIds.Contains(p.PeopleId) && p.AttachedId == data.AutoTokenId)
                .AsEnumerable();

                data.PeoplesOutOfDatabase = peoples.ToList();
            }
        }
Exemplo n.º 29
0
 public Guid[] ParsersRemove(Guid[] ids)
 {
     List<Guid> result = new List<Guid>();
     if (ids != null)
         using (var dc = exelconverterEntities2.New())
         {
             //var dc = exelconverterEntities2.Default;
             var parsersToRemove = dc.parsers.Where(p => ids.Contains(p.id)).ToArray();
             if (parsersToRemove.Length > 0)
             {
                 foreach (var p in parsersToRemove)
                 {
                     result.Add(p.id);
                     dc.parsers.Remove(p);
                 }
                 dc.SaveChanges();
             }
         }
     return result.ToArray();
 }
Exemplo n.º 30
0
 public bool IsAnyStateContainedInNavigationStack(Guid[] workflowStateIds)
 {
   EnterReadLock("IsAnyStateContainedInNavigationStack");
   try
   {
     return _navigationContextStack.Any(context => workflowStateIds.Contains(context.WorkflowState.StateId));
   }
   finally
   {
     ExitReadLock();
   }
 }