public Paged <ActivityEntry> Get(int pageIndex, int pageSize)
        {
            List <ActivityEntry> list = null;
            int    totalCount         = 0;
            String procName           = "[dbo].[ActivityEntries_SelectByPage]";

            _dataProvider.ExecuteCmd(procName
                                     , inputParamMapper : delegate(SqlParameterCollection paramCollection)
            {
                paramCollection.AddWithValue("@PageIndex", pageIndex);
                paramCollection.AddWithValue("@PageSize", pageSize);
            }
                                     , singleRecordMapper : delegate(IDataReader reader, short set)
            {
                ActivityEntry activity = MapActivity(reader);
                if (totalCount == 0)
                {
                    totalCount = reader.GetInt32(14);
                }
                if (list == null)
                {
                    list = new List <ActivityEntry>();
                }

                list.Add(activity);
            }
                                     );
            Paged <ActivityEntry> page = null;

            if (list != null)
            {
                page = new Paged <ActivityEntry>(list, pageIndex, pageSize, totalCount);
            }
            return(page);
        }
Example #2
0
        public async Task <bool> UpdateActivityEntryAsync(ActivityEntry activityEntryToUpdate)
        {
            _dbContext.ActivityEntries.Update(activityEntryToUpdate);
            var updated = await _dbContext.SaveChangesAsync();

            return(updated > 0);
        }
        public async Task <IActionResult> Edit(int id, [Bind("ActivityEntryId,ActivityTime,ActivityDuration,PetId,ActivityTypeId")] ActivityEntry activityEntryToUpdate, int page = 1)
        {
            if (User.Identity.IsAuthenticated)
            {
                if (id != activityEntryToUpdate.ActivityEntryId)
                {
                    return(NotFound());
                }
                if (ModelState.IsValid)
                {
                    var updateStatus = await _activityEntryService.UpdateActivityEntryAsync(activityEntryToUpdate);

                    if (!updateStatus)
                    {
                        return(RedirectToAction("Index", "EditEntries", new { error = true, msgToDisplay = "An error has occured with the databse." }));
                    }
                    var goalReached = _activityEntryService.DailyActivityGoalReached(activityEntryToUpdate.PetId);
                    return(RedirectToAction("Index", "EditEntries", new { id = page, updated = true, msgToDisplay = "Activity entry has been successfully updated." }));
                }
                ViewBag.Page = page;
                ViewData["ActivityTypeId"] = await _activityEntryService.GetActivityTypesAsync();

                return(View(activityEntryToUpdate));
            }
            return(RedirectToAction("Index", "NotAuthorized"));
        }
Example #4
0
 private void SaveEntriesForActivity(string activityId, IList <ActivityEntry> entries)
 {
     if (CollectionUtils.IsNullOrEmpty(entries))
     {
         return;
     }
     object[] insertValues = new object[5];
     DoBulkInsert(DETAIL_TABLE_NAME, "Id;ActivityId;Detail;ModifiedOn;OrderIndex",
                  delegate(int currentInsertIndex)
     {
         if (currentInsertIndex < entries.Count)
         {
             ActivityEntry entry = entries[currentInsertIndex];
             insertValues[0]     = IdProvider.Get();
             insertValues[1]     = activityId;
             insertValues[2]     = LimitDbText(entry.Message, MAX_DETAIL_CHARS);
             insertValues[3]     = entry.TimeStamp;
             insertValues[4]     = currentInsertIndex;
             return(insertValues);
         }
         else
         {
             return(null);
         }
     });
 }
        public async Task <IActionResult> Create([Bind("ActivityEntryId,ActivityTime,ActivityDuration,PetId,ActivityTypeId")] ActivityEntry newActivityEntry)
        {
            if (User.Identity.IsAuthenticated)
            {
                if (ModelState.IsValid)
                {
                    newActivityEntry.ActivityTime = DateTime.Now;
                    var returnValue = await _activityEntryService.CreateActivityEntryAsync(newActivityEntry);

                    if (!returnValue)
                    {
                        return(RedirectToAction("Index", "Home", new { error = true, msgToDisplay = "An error has occured with the database" }));
                    }
                    var goalReached = _activityEntryService.DailyActivityGoalReached(newActivityEntry.PetId);
                    return(RedirectToAction("Index", "Home", new { goalReached = goalReached, goalText = "daily activity goal", added = true, msgToDisplay = "New activity entry has been addded!" }));
                }
                var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
                ViewData["PetId"] = await _petService.GetPetsSelectListAsync(userId);

                ViewData["ActivityTypeId"] = await _activityEntryService.GetActivityTypesAsync();

                return(View(newActivityEntry));
            }
            return(RedirectToAction("Index", "NotAuthorized"));
        }
Example #6
0
 public void DeleteActivityEntry(ActivityEntry activityEntry)
 {
     if (activityEntry == null)
     {
         throw new ArgumentNullException(nameof(activityEntry));
     }
     _context.ActivityEntries.Remove(activityEntry);
 }
Example #7
0
        public async Task <bool> CreateActivityEntryAsync(ActivityEntry activityEntry)
        {
            await _dbContext.ActivityEntries.AddAsync(activityEntry);

            var created = await _dbContext.SaveChangesAsync();

            return(created > 0);
        }
Example #8
0
 public void AddActivityEntry(ActivityEntry activityEntry)
 {
     if (activityEntry == null)
     {
         throw new ArgumentNullException(nameof(activityEntry));
     }
     _context.ActivityEntries.Add(activityEntry);
 }
Example #9
0
 public ActivityViewModel(ActivityEntry activity)
 {
     Title      = AppResource.EditActivity;
     IsEditView = true;
     Activity   = activity;
     Name       = Activity.Name;
     Calories   = Activity.Calories;
 }
Example #10
0
 public void RecordAction(DebugActionType actionType, Slice key, string treeName, object value)
 {
     if (IsRecording)
     {
         var newAction = new ActivityEntry(actionType, key, treeName, value);
         WriteQueue.Enqueue(newAction);
         _journalWriter.WriteLine(newAction.ToCsvLine(RecordOnlyValueLength));
     }
 }
        /// <summary>
        /// Gets the entry of registration of activity according specified ModelItem object.
        /// </summary>
        /// <param name="item">The specified ModelItem object.</param>
        /// <returns>The entry of registration of activity represented by the specified ModelItem object.</returns>
        public static ActivityEntry GetActivityEntry(this ModelItem item)
        {
            RuleEditingContext  context         = item.GetRuleEditingContext();
            RuleManager         ruleManager     = context.GetRuleSignature().Owner;
            RuleActivityManager activityManager = ruleManager.ActivityManager;
            ActivityEntry       entry           = activityManager.GetEntry(item.ItemType);

            return(entry);
        }
Example #12
0
        private ActivityEntry MapActivityDetail(IDataReader reader)
        {
            ActivityEntry activityEntry = new ActivityEntry();
            int           index         = 0;

            activityEntry.Message   = reader.GetString(index++);
            activityEntry.TimeStamp = reader.GetDateTime(index++);
            return(activityEntry);
        }
Example #13
0
 private static wptType Convert(ActivityEntry e)
 {
     return(new wptType
     {
         lat = (decimal)e.latitude,
         lon = (decimal)e.longitude,
         ele = (decimal)e.altitude,
     });
 }
Example #14
0
        public ActivityEntryContract(ActivityEntry entry, ContentLanguagePreference languagePreference)
        {
            ParamIs.NotNull(() => entry);

            ArtistString = GetArtistString(entry.EntryBase, languagePreference);
            Author       = new UserContract(entry.Author);
            CreateDate   = entry.CreateDate;
            EditEvent    = entry.EditEvent;
            EntryRef     = new EntryWithImageContract(entry.EntryBase, GetMime(entry.EntryBase), GetSongThumbUrl(entry.EntryBase), languagePreference);
        }
        private static string FallbackTranslateItem(ActivityTranslator translator, ModelItem item)
        {
            ActivityEntry entry = item.GetActivityEntry();

            if (null != entry)
            {
                return(entry.DisplayName);
            }
            return(item.GetCurrentValue().ToString());
        }
Example #16
0
        protected void AddActivityfeedEntry(ISession session, ActivityEntry entry)
        {
            var latestEntries = session.Query <ActivityEntry>().OrderByDescending(a => a.CreateDate).Take(10).ToArray();

            if (latestEntries.Any(e => e.IsDuplicate(entry)))
            {
                return;
            }

            session.Save(entry);
        }
        public async Task <bool> CreateActivityEntry(int minutes, int typeId, int petId)
        {
            var activityEntry = new ActivityEntry
            {
                ActivityDuration = minutes,
                ActivityTypeId   = typeId,
                PetId            = petId,
                ActivityTime     = DateTime.Now
            };

            return(await _activityEntryService.CreateActivityEntryAsync(activityEntry));
        }
Example #18
0
        public ActivityEntryViewModel MapActivityEntry(ActivityEntry activityEntry)
        {
            var activityEntryViewModel = new ActivityEntryViewModel
            {
                ActivityEntryId  = activityEntry.ActivityEntryId,
                ActivityTime     = activityEntry.ActivityTime,
                ActivityDuration = activityEntry.ActivityDuration,
                PetId            = activityEntry.PetId
            };

            return(activityEntryViewModel);
        }
Example #19
0
        public override object CreateNewInstance(SelectItem item)
        {
            Debug.Assert(item.Value is ActivityEntry);
            ActivityEntry activityEntry = item.Value as ActivityEntry;

            // Get old item, parent item and parent item property
            Debug.Assert(Parent.OwnerItem != null && Parent.ItemName != null);
            ModelProperty   parentProperty  = Parent.OwnerItem.Properties[Parent.ItemName];
            ActivityFactory activityFactory = Parent.EditingContext.Services.GetService <ActivityFactory>();
            Activity        newActivity     = activityFactory.CreateActivity(activityEntry.Create, Parent.GetModelProperty());

            return(newActivity);
        }
Example #20
0
        public async Task AddActivityfeedEntryAsync(ActivityEntry entry)
        {
            var latestEntries = await _ctx.Query()
                                .OrderByDescending(a => a.CreateDate)
                                .Take(10)   // time cutoff would be better instead of an arbitrary number of activity entries
                                .VdbToListAsync();

            if (latestEntries.Any(e => e.IsDuplicate(entry)))
            {
                return;
            }

            await _ctx.SaveAsync(entry);
        }
Example #21
0
        protected void AddActivityfeedEntry(ISession session, ActivityEntry entry)
        {
            var latestEntries = session.Query <ActivityEntry>()
                                .OrderByDescending(a => a.CreateDate)
                                .Take(10)   // time cutoff would be better instead of an arbitrary number of activity entries
                                .ToArray();

            if (latestEntries.Any(e => e.IsDuplicate(entry)))
            {
                return;
            }

            session.Save(entry);
        }
Example #22
0
        protected void AddActivityfeedEntry(IRepositoryContext <ActivityEntry> ctx, ActivityEntry entry)
        {
            var latestEntries = ctx.Query()
                                .OrderByDescending(a => a.CreateDate)
                                .Take(10)       // time cutoff would be better instead of an arbitrary number of activity entries
                                .ToArray();

            if (latestEntries.Any(e => e.IsDuplicate(entry)))
            {
                return;
            }

            ctx.Save(entry);
        }
Example #23
0
        public void AddActivityfeedEntry(ActivityEntry entry)
        {
            var latestEntries = _ctx.Query()
                                .OrderByDescending(a => a.CreateDate)
                                .Take(10)   // time cutoff would be better instead of an arbitrary number of activity entries
                                .ToArray();

            if (latestEntries.Any(e => e.IsDuplicate(entry)))
            {
                return;
            }

            _ctx.Save(entry);
        }
Example #24
0
 public void Load(string journalName)
 {
     using (var journalReader = new StreamReader(_journalFileStream, Encoding.UTF8))
     {
         while (journalReader.Peek() >= 0)
         {
             var csvLine = journalReader.ReadLine();
             if (!string.IsNullOrWhiteSpace(csvLine))
             {
                 WriteQueue.Enqueue(ActivityEntry.FromCsvLine(csvLine, RecordOnlyValueLength));
             }
         }
     }
 }
        public IActionResult Post(ActivityEntry newActivityEntry)
        {
            if (ModelState.IsValid)
            {
                using (ActivityEntryContext db = new ActivityEntryContext())
                {
                    db.ActivityEntries.Add(newActivityEntry);
                    db.SaveChanges();

                    return(Ok(true));
                }
            }
            else
            {
                return(BadRequest("First Name, Last Name, Email, Activity and Comments are Required"));
            }
        }
        public ActivityEntryForApiContract(ActivityEntry activityEntry, EntryForApiContract entryForApiContract,
                                           IUserIconFactory userIconFactory,
                                           IUserPermissionContext permissionContext,
                                           ActivityEntryOptionalFields fields)
        {
            CreateDate = activityEntry.CreateDate.ToUniversalTime();
            EditEvent  = activityEntry.EditEvent;

            if (activityEntry.Author != null &&
                ((permissionContext.IsLoggedIn && (permissionContext.LoggedUserId == activityEntry.Author.Id || permissionContext.HasPermission(PermissionToken.DisableUsers))) ||
                 !activityEntry.Author.AnonymousActivity))
            {
                Author = new UserForApiContract(activityEntry.Author, userIconFactory, UserOptionalFields.MainPicture);
            }

            if (fields.HasFlag(ActivityEntryOptionalFields.ArchivedVersion) && activityEntry.ArchivedVersionBase != null)
            {
                ArchivedVersion = new ArchivedObjectVersionForApiContract(activityEntry.ArchivedVersionBase);
            }

            Entry = entryForApiContract;
        }
        private static ActivityEntry MapActivity(IDataReader reader)
        {
            Sabio.Models.Domain.ActivityEntry activity = new ActivityEntry();

            int startingIndex = 0;

            activity.Id             = reader.GetInt32(startingIndex++);
            activity.UserId         = reader.GetSafeInt32(startingIndex++);
            activity.PetId          = reader.GetSafeInt32(startingIndex++);
            activity.IsActive       = reader.GetSafeBool(startingIndex++);
            activity.DateStart      = reader.GetSafeDateTime(startingIndex++);
            activity.DateEnd        = reader.GetSafeDateTime(startingIndex++);
            activity.ActivityTypeId = reader.GetSafeInt32(startingIndex++);
            activity.Value          = reader.GetSafeString(startingIndex++);
            activity.TimeElapsed    = reader.GetSafeInt32(startingIndex++);
            activity.PointsEarned   = reader.GetSafeInt32(startingIndex++);
            activity.ChallengeId    = reader.GetSafeInt32(startingIndex++);
            activity.Notes          = reader.GetSafeString(startingIndex++);
            activity.PhotoUrl       = reader.GetSafeString(startingIndex++);
            activity.DateCreated    = reader.GetSafeDateTime(startingIndex++);
            activity.DateModified   = reader.GetSafeDateTime(startingIndex++);
            return(activity);
        }
        public List <ActivityEntry> Get()
        {
            List <Sabio.Models.Domain.ActivityEntry> list = null;
            string procName = "[dbo].[ActivityEntries_SelectAll]";

            _dataProvider.ExecuteCmd(procName
                                     , inputParamMapper : delegate(SqlParameterCollection parameterCollection)
            {
            }
                                     , singleRecordMapper : delegate(IDataReader reader, short set)
            {
                ActivityEntry activity = MapActivity(reader);

                if (list == null)
                {
                    list = new List <Sabio.Models.Domain.ActivityEntry>();
                }

                list.Add(activity);
            }
                                     );
            return(list);
        }
        public Paged <ActivityEntry> GetAllActivitiesForUserId(int userId, int pageIndex, int pageSize)
        {
            Paged <ActivityEntry> response = null;
            List <ActivityEntry>  list     = null;
            int    totalCount = 0;
            string prokName   = "[dbo].[ActivityEntries_PageActivitiesForUserId]";

            _dataProvider.ExecuteCmd(prokName
                                     , inputParamMapper : delegate(SqlParameterCollection paramCollection)
            {
                paramCollection.AddWithValue("@PageIndex", pageIndex);
                paramCollection.AddWithValue("@PageSize", pageSize);
                paramCollection.AddWithValue("@UserId", userId);
            }
                                     , singleRecordMapper : delegate(IDataReader reader, short set)
            {
                ActivityEntry activity = new ActivityEntry();
                activity = MapActivity(reader);
                if (totalCount == 0)
                {
                    totalCount = reader.GetSafeInt32(14);
                }
                if (list == null)
                {
                    list = new List <ActivityEntry>();
                }

                list.Add(activity);
            }
                                     );
            if (list != null)
            {
                response = new Paged <ActivityEntry>(list, pageIndex, pageSize, totalCount);
                return(response);
            }
            return(response);
        }
        public List <ActivityEntry> GetOpenActivities(int userId)
        {
            List <ActivityEntry> list = null;
            string procName           = "[dbo].[ActivityEntries_SelectIsActive]";

            _dataProvider.ExecuteCmd(procName
                                     , inputParamMapper : delegate(SqlParameterCollection parameterCollection)
            {
                parameterCollection.AddWithValue("@UserId", userId);
            }
                                     , singleRecordMapper : delegate(IDataReader reader, short set)
            {
                ActivityEntry activity = MapActivity(reader);

                if (list == null)
                {
                    list = new List <ActivityEntry>();
                }

                list.Add(activity);
            }
                                     );
            return(list);
        }
Example #31
0
            public static ActivityEntry FromCsvLine(string csvLine, bool recordOnlyValueLength)
            {
                var columnArray = csvLine.Split(new[] { ',' }).ToList();
                if (columnArray.Count != 4)
                    throw new ArgumentException("invalid csv data - check that you do not have commas in data");

                try
                {
                    if (columnArray[0] == DebugActionType.CreateTree.ToString())
                    {
                        var activityEntry = new ActivityEntry(
                            GenericUtil.ParseEnum<DebugActionType>(columnArray[0]),
                            Slice.Empty,
                            columnArray[1],
                            null);
                        return activityEntry;
                    }

                    if (columnArray[0] == DebugActionType.Delete.ToString())
                    {
                        var activityEntry = new ActivityEntry(
                            GenericUtil.ParseEnum<DebugActionType>(columnArray[0]),
                            columnArray[2],
                            columnArray[1],
                            null);

                        return activityEntry;
                    }

                    var random = new Random();

                    var type = GenericUtil.ParseEnum<DebugActionType>(columnArray[0]);
                    object value;
                    switch (type)
                    {
                        case DebugActionType.MultiAdd:
                        case DebugActionType.MultiDelete:
                               value = new Slice(Encoding.UTF8.GetBytes(columnArray[3]));
                            break;
                        default:
                            if (recordOnlyValueLength)
                            {
                                var length = long.Parse(columnArray[3]);
                                var bytes = new byte[length];
                                random.NextBytes(bytes);

                                value = new MemoryStream(bytes);
                            }
                            else
                                value = new MemoryStream(Encoding.UTF8.GetBytes(columnArray[3]));
                            break;
                    }

                    var entry = new ActivityEntry(type,
                        columnArray[2],
                        columnArray[1],
                        value);

                    return entry;
                }
                catch (Exception e)
                {
                    throw new ArgumentException("Unable to parse the argument", e);
                }
            }
Example #32
0
 public void RecordAction(DebugActionType actionType, Slice key, string treeName, object value)
 {
     if (IsRecording)
     {
         var newAction = new ActivityEntry(actionType, key, treeName, value);
         WriteQueue.Enqueue(newAction);
         _journalWriter.WriteLine(newAction.ToCsvLine(RecordOnlyValueLength));
     }
 }