Example #1
0
        public async Task <IActionResult> Edit(int id, [Bind("AutoId,ActGroupId,ActGroupName,IsReflectedInReportCard,ActGroupReportCard,ActGroupMotive,ActCode,GradeType,Clss,ActSn,ActClss,ActSession")] ActivityGroup activityGroup)
        {
            if (id != activityGroup.AutoId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(activityGroup);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ActivityGroupExists(activityGroup.AutoId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(activityGroup));
        }
        public ActionResult DeleteConfirmed(int id)
        {
            ActivityGroup activityGroup = db.ActivityGroups.Find(id);

            db.ActivityGroups.Remove(activityGroup);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Example #3
0
 public void DeleteActivityGroup(ActivityGroup activityGroup)
 {
     activityGroup.ActivityRef.ActivitiesGroupsRef.Remove(activityGroup);
     activityGroup.GroupRef.ActivitiesGroupsRef.Remove(activityGroup);
     AllActivityGroupItems.Remove(activityGroup);
     db.ActivityGroup.DeleteOnSubmit(activityGroup);
     db.SubmitChanges();
 }
        private DailySummaryForActivity BuildSummaryForActivity(ActivityGroup activityGroup)
        {
            var summary = new DailySummaryForActivity(_numDays)
            {
                ActivityGroupId        = activityGroup.Id,
                Key                    = "id|" + activityGroup.Id,
                Name                   = activityGroup.Name,
                Position               = activityGroup.Position,
                ParentActivityGroupId  = activityGroup.ParentId,
                TracksPollResponseText = !string.IsNullOrEmpty(activityGroup.MatchResponseText)
            };

            var children = new List <DailySummaryForActivity>();

            // Add this summary to the ResponseText lookup table.
            if (!string.IsNullOrEmpty(activityGroup.MatchResponseText))
            {
                if (activityGroup.HasChildren())
                {
                    // We need to create another made-up activity group that represents the
                    // exact ResponseText matches.
                    var matchedResponseSummary = new DailySummaryForActivity(_numDays)
                    {
                        Key      = "name|" + activityGroup.MatchResponseText,
                        Name     = activityGroup.MatchResponseText,
                        Position = 0,
                        TracksPollResponseText   = true,
                        TracksExactParentMatches = true
                    };

                    _summariesByResponseText[activityGroup.MatchResponseText] = matchedResponseSummary;
                    children.Add(matchedResponseSummary);
                }
                else
                {
                    // This is a leaf node.
                    _summariesByResponseText[activityGroup.MatchResponseText] = summary;
                }
            }

            // Populate the children
            if (activityGroup.HasChildren())
            {
                foreach (var childGroup in activityGroup.Children)
                {
                    var childSummary = BuildSummaryForActivity(childGroup);
                    children.Add(childSummary);
                }
            }

            if (children.Any())
            {
                summary.Children = children;
            }

            return(summary);
        }
Example #5
0
        public void CreateActivityGroup(Activity activity, Group group)
        {
            ActivityGroup activityGroup = new ActivityGroup();

            db.ActivityGroup.InsertOnSubmit(activityGroup);
            activity.ActivitiesGroupsRef.Add(activityGroup);
            group.ActivitiesGroupsRef.Add(activityGroup);
            db.SubmitChanges();
            AllActivityGroupItems.Add(activityGroup);
        }
 public ActionResult Edit([Bind(Include = "Id,Name")] ActivityGroup activityGroup)
 {
     if (ModelState.IsValid)
     {
         db.Entry(activityGroup).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(activityGroup));
 }
        public ActionResult Create([Bind(Include = "Id,Name")] ActivityGroup activityGroup)
        {
            if (ModelState.IsValid)
            {
                db.ActivityGroups.Add(activityGroup);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(activityGroup));
        }
Example #8
0
        public async Task Group__CurrentWithoutInputAndNextWithoutInput__ShouldBeProcessed()
        {
            var current = new Empty();
            var next    = new Empty();
            var group   = new ActivityGroup(current, next);

            await group.ExecuteAsync(() => Task.CompletedTask, new System.Threading.CancellationToken());

            Assert.True(current.Processed);
            Assert.True(next.Processed);
        }
 public Summary(ActivityType activity, float duration, double distance, float calories)
 {
     this.activity = activity;
     group         = HelpMethods.ReturnGroup(activity);
     this.duration = duration;
     this.distance = Math.Round(distance * 1000);
     if (calories > 0)
     {
         this.calories = calories;
     }
 }
Example #10
0
        public async Task Group__CurrentWithOutputAndNextWithInput__ShouldBeProcessed()
        {
            var input   = 4;
            var current = new Returns <int, int> {
                Selector = x => x
            };
            var next  = new Accepts <int>();
            var group = new ActivityGroup <int>(current, next);

            await group.ExecuteAsync(input, () => Task.CompletedTask, new System.Threading.CancellationToken());

            Assert.Equal(input, next.Value);
        }
        /// <summary>
        /// Run the code example.
        /// </summary>
        public void Run(AdManagerUser user)
        {
            using (ActivityGroupService activityGroupService =
                       user.GetService <ActivityGroupService>())
            {
                // Set the ID of the activity group and the company to update it with.
                int  activityGroupId     = int.Parse(_T("INSERT_ACTIVITY_GROUP_ID_HERE"));
                long advertiserCompanyId = long.Parse(_T("INSERT_ADVERTISER_COMPANY_ID_HERE"));

                try
                {
                    // Get the activity group.
                    StatementBuilder statementBuilder = new StatementBuilder()
                                                        .Where("id = :id")
                                                        .OrderBy("id ASC")
                                                        .Limit(1)
                                                        .AddValue("id", activityGroupId);

                    ActivityGroupPage page =
                        activityGroupService.getActivityGroupsByStatement(statementBuilder
                                                                          .ToStatement());

                    ActivityGroup activityGroup = page.results[0];

                    // Update the companies.
                    List <long> companyIds = new List <long>(activityGroup.companyIds);
                    companyIds.Add(advertiserCompanyId);
                    activityGroup.companyIds = companyIds.ToArray();

                    // Update the activity groups on the server.
                    ActivityGroup[] activityGroups = activityGroupService.updateActivityGroups(
                        new ActivityGroup[]
                    {
                        activityGroup
                    });

                    // Display results.
                    foreach (ActivityGroup updatedActivityGroup in activityGroups)
                    {
                        Console.WriteLine(
                            "Activity group with ID \"{0}\" and name \"{1}\" was updated.",
                            updatedActivityGroup.id, updatedActivityGroup.name);
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine("Failed to update activity groups. Exception says \"{0}\"",
                                      e.Message);
                }
            }
        }
        // GET: ActivityGroups/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            ActivityGroup activityGroup = db.ActivityGroups.Find(id);

            if (activityGroup == null)
            {
                return(HttpNotFound());
            }
            return(View(activityGroup));
        }
Example #13
0
        /// <summary>
        /// Run the code example.
        /// </summary>
        /// <param name="user">The DFP user object running the code example.</param>
        public override void Run(DfpUser user)
        {
            // Get the ActivityGroupService.
            ActivityGroupService activityGroupService =
                (ActivityGroupService)user.GetService(DfpService.v201405.ActivityGroupService);

            // Set the ID of the advertiser company this activity group is associated
            // with.
            long advertiserCompanyId = long.Parse(_T("INSERT_ADVERTISER_COMPANY_ID_HERE"));

            // Create a short-term activity group.
            ActivityGroup shortTermActivityGroup = new ActivityGroup();

            shortTermActivityGroup.name                = "Short-term activity group #" + GetTimeStamp();
            shortTermActivityGroup.companyIds          = new long[] { advertiserCompanyId };
            shortTermActivityGroup.clicksLookback      = 1;
            shortTermActivityGroup.impressionsLookback = 1;

            // Create a long-term activity group.
            ActivityGroup longTermActivityGroup = new ActivityGroup();

            longTermActivityGroup.name                = "Long-term activity group #" + GetTimeStamp();
            longTermActivityGroup.companyIds          = new long[] { advertiserCompanyId };
            longTermActivityGroup.clicksLookback      = 30;
            longTermActivityGroup.impressionsLookback = 30;

            try {
                // Create the activity groups on the server.
                ActivityGroup[] activityGroups = activityGroupService.createActivityGroups(
                    new ActivityGroup[] { shortTermActivityGroup, longTermActivityGroup });

                // Display results.
                if (activityGroups != null)
                {
                    foreach (ActivityGroup activityGroup in activityGroups)
                    {
                        Console.WriteLine("An activity group with ID \"{0}\" and name \"{1}\" was created.",
                                          activityGroup.id, activityGroup.name);
                    }
                }
                else
                {
                    Console.WriteLine("No activity groups were created.");
                }
            } catch (Exception ex) {
                Console.WriteLine("Failed to create activity groups. Exception says \"{0}\"", ex.Message);
            }
        }
 public Activity(ActivityType type, ActivityGroup group, DateTime startTime,
                 DateTime endTime, double duration, double distance,
                 double calories, List <TrackPoint> trackpoints)
 {
     activity       = type;
     this.group     = group;
     this.startTime = HelpMethods.ConvertToIso1601(startTime);
     this.endTime   = HelpMethods.ConvertToIso1601(endTime);
     this.duration  = duration;
     this.distance  = Math.Round(distance * 1000);
     if (calories > 0)
     {
         this.calories = calories;
     }
     this.trackPoints = trackpoints.ToArray();
 }
Example #15
0
        protected ActivityGroup InsertActivityGroup(string name, Guid?parentId = null, string matchResponseText = null)
        {
            var activityGroup = new ActivityGroup
            {
                Id                = Guid.NewGuid(),
                ParentId          = parentId,
                Name              = name,
                MatchResponseText = matchResponseText,
                PollId            = DefaultPollId,
                Position          = 0
            };

            Db.Mock.ActivityGroups.QueryData.Add(activityGroup);

            return(activityGroup);
        }
        ConvertedActivity ConvertActivityGroupToContinuation(
            ActivityGroup activityGroup, 
            Job parent,
            IEnumerable<ExceptionFilter> inheritedExceptionFilters)
        {
            var jobs = Enumerable.Empty<Job>();

            /*
             *  Activities in a group inherit exception filters defined
             *  in the group as well as the ones inherited by the group.
             */
            var effectiveExceptionFilters = inheritedExceptionFilters.Concat(activityGroup.ExceptionFilters).ToArray();

            var convertedItems =
                activityGroup.Items.Select(item => ConvertCore(item, parent, effectiveExceptionFilters)).ToArray();

            jobs = convertedItems.Aggregate(jobs, (current, converted) => current.Concat(converted.Jobs));

            var continuation = new Continuation
            {
                Type = activityGroup.IsParallel ? ContinuationType.Parallel : ContinuationType.Sequence,
                ContinueAfterHandlingFailure = activityGroup.CanContinueAfterHandlingFailure,
                Children = convertedItems.Select(c => c.Continuation)
            };

            var onNext = ConvertCore(activityGroup.Next, parent, effectiveExceptionFilters);
            continuation.Next = onNext.Continuation;
            jobs = jobs.Concat(onNext.Jobs);

            var onAnyFailed = ConvertCore(activityGroup.OnAnyFailed, parent, effectiveExceptionFilters);
            continuation.OnAnyFailed = onAnyFailed.Continuation;
            jobs = jobs.Concat(onAnyFailed.Jobs);

            var onAllFailed = ConvertCore(activityGroup.OnAllFailed, parent, effectiveExceptionFilters);
            continuation.OnAllFailed = onAllFailed.Continuation;
            jobs = jobs.Concat(onAllFailed.Jobs);

            var onCancelled = ConvertCore(activityGroup.OnCancel, parent, effectiveExceptionFilters);
            if (onCancelled.Continuation != null)
                onCancelled.Continuation.CompensateForCancellation = true;
            continuation.OnCancelled = onCancelled.Continuation;
            jobs = jobs.Concat(onCancelled.Jobs);

            return new ConvertedActivity(continuation, jobs);
        }
        public async Task <IActionResult> PostActivityGroup([FromBody] ActivityGroup activityGroup)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            try
            {
                var conn = _context.Database.GetDbConnection();
                if (conn.State == ConnectionState.Closed)
                {
                    await conn.OpenAsync();
                }
                using (var command = conn.CreateCommand())
                {
                    MySql = " INSERT INTO ActivityGroup (ActGroupID, ActGroupName, IsReflectedInReportCArd, ActGroupReportCard,"
                            + "ActGroupMotive, ActCode, GradeType, Clss, ActSn, ActClss, ActSession, ";
                    MySql = MySql + " Dormant, LoginName, ModTime, cTerminal, dBID) Values (0, '";
                    MySql = MySql + activityGroup.ActGroupName + "'," + CBI(activityGroup.IsReflectedInReportCard) + ",'"
                            + activityGroup.ActGroupReportCard + "','" + activityGroup.ActGroupMotive + "','"
                            + activityGroup.ActCode + "','" + activityGroup.GradeType + "','" + activityGroup.Clss + "',"
                            + activityGroup.ActSn + ",'" + activityGroup.ActClss + "','"
                            + activityGroup.ActSession + "',";
                    MySql = MySql + "0,'" + activityGroup.LoginName + "'," + GenFunc.GloFunc.ToOADate(DateTime.Now);
                    MySql = MySql + ",'" + activityGroup.CTerminal + "'," + activityGroup.DBid + ")";

                    command.CommandType = CommandType.Text;
                    command.CommandText = MySql;
                    command.ExecuteNonQuery();
                }
                //UpdateAcaSession(acaSession);
                //    await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                throw;
            }

            //_context.ActivityGroup.Add(activityGroup);
            //await _context.SaveChangesAsync();
            return(CreatedAtAction("GetActivityGroup", new { id = activityGroup.AutoId }, activityGroup));
        }
Example #18
0
        ConvertedActivity ConvertActivityGroupToContinuation(
            ActivityGroup activityGroup,
            Job parent,
            IEnumerable <ExceptionFilter> inheritedExceptionFilters)
        {
            var jobs = Enumerable.Empty <Job>();

            /*
             *  Activities in a group inherit exception filters defined
             *  in the group as well as the ones inherited by the group.
             */
            var effectiveExceptionFilters = inheritedExceptionFilters.Concat(activityGroup.ExceptionFilters).ToArray();

            var convertedItems =
                activityGroup.Items.Select(item => ConvertCore(item, parent, effectiveExceptionFilters)).ToArray();

            jobs = convertedItems.Aggregate(jobs, (current, converted) => current.Concat(converted.Jobs));

            var continuation = new Continuation
            {
                Type = activityGroup.IsParallel ? ContinuationType.Parallel : ContinuationType.Sequence,
                ContinueAfterHandlingFailure = activityGroup.CanContinueAfterHandlingFailure,
                Children = convertedItems.Select(c => c.Continuation)
            };

            var onNext = ConvertCore(activityGroup.Next, parent, effectiveExceptionFilters);

            continuation.Next = onNext.Continuation;
            jobs = jobs.Concat(onNext.Jobs);

            var onAnyFailed = ConvertCore(activityGroup.OnAnyFailed, parent, effectiveExceptionFilters);

            continuation.OnAnyFailed = onAnyFailed.Continuation;
            jobs = jobs.Concat(onAnyFailed.Jobs);

            var onAllFailed = ConvertCore(activityGroup.OnAllFailed, parent, effectiveExceptionFilters);

            continuation.OnAllFailed = onAllFailed.Continuation;
            jobs = jobs.Concat(onAllFailed.Jobs);

            return(new ConvertedActivity(continuation, jobs));
        }
Example #19
0
        public async Task <IActionResult> Create([Bind("ActGroupName,IsReflectedInReportCard,ActGroupReportCard,ActGroupMotive,ActCode,GradeType,Clss,ActSn")] ActivityGroup activityGroup)
        {
            if (ModelState.IsValid)
            {
                if (!ActivityGroupExists(activityGroup.ActGroupName))
                {
                    using (HttpClient client = new HttpClient())
                    {
                        client.BaseAddress = new Uri(GloVar.iBaseURI);
                        MediaTypeWithQualityHeaderValue contentType = new MediaTypeWithQualityHeaderValue("application/json");
                        client.DefaultRequestHeaders.Accept.Add(contentType);
                        string stringData            = JsonConvert.SerializeObject(activityGroup);
                        var    contentData           = new StringContent(stringData, System.Text.Encoding.UTF8, "application/json");
                        HttpResponseMessage response = client.PostAsync("/api/ActivityGroups", contentData).Result;
                        ViewBag.Message = response.Content.ReadAsStringAsync().Result;
                        if (response.IsSuccessStatusCode)
                        {
                            ViewBag.Remark = "Creation of Activity Group '" + activityGroup.ActGroupName + "' Successful";
                            return(View());
                        }
                        else
                        {
                            ViewBag.Remark = "Creation of Session Group '" + activityGroup.ActGroupName + "' Failed!. Please Try Again";
                            return(View(activityGroup));
                        }
                    }
                }
                else
                {
                    return(View(activityGroup));
                }
            }

            //if (ModelState.IsValid)
            //{
            //    _context.Add(activityGroup);
            //    await _context.SaveChangesAsync();
            //    return RedirectToAction(nameof(Index));
            //}
            //return View(activityGroup);
            return(RedirectToAction("Index"));
        }
Example #20
0
        public async Task Group__CurrentWithOutputAndNextWithOutput__ShouldBeProcessed()
        {
            var input  = 4;
            var output = string.Empty;
            var group  = new ActivityGroup <int, int, string>(
                new Returns <int, int> {
                Selector = x => x
            },
                new Returns <int, string> {
                Selector = x => x.ToString()
            });

            await group.ExecuteAsync(input, x =>
            {
                output = x;
                return(Task.CompletedTask);
            }, new System.Threading.CancellationToken());

            Assert.Equal("4", output);
        }
    /// <summary>
    /// Run the code example.
    /// </summary>
    /// <param name="user">The DFP user object running the code example.</param>
    public override void Run(DfpUser user) {
      // Get the ActivityGroupService.
      ActivityGroupService activityGroupService =
          (ActivityGroupService) user.GetService(DfpService.v201511.ActivityGroupService);

      // Set the ID of the advertiser company this activity group is associated
      // with.
      long advertiserCompanyId = long.Parse(_T("INSERT_ADVERTISER_COMPANY_ID_HERE"));

      // Create a short-term activity group.
      ActivityGroup shortTermActivityGroup = new ActivityGroup();
      shortTermActivityGroup.name = "Short-term activity group #" + GetTimeStamp();
      shortTermActivityGroup.companyIds = new long[] {advertiserCompanyId};
      shortTermActivityGroup.clicksLookback = 1;
      shortTermActivityGroup.impressionsLookback = 1;

      // Create a long-term activity group.
      ActivityGroup longTermActivityGroup = new ActivityGroup();
      longTermActivityGroup.name = "Long-term activity group #" + GetTimeStamp();
      longTermActivityGroup.companyIds = new long[] {advertiserCompanyId};
      longTermActivityGroup.clicksLookback = 30;
      longTermActivityGroup.impressionsLookback = 30;

      try {
        // Create the activity groups on the server.
        ActivityGroup[] activityGroups = activityGroupService.createActivityGroups(
            new ActivityGroup[] {shortTermActivityGroup, longTermActivityGroup});

        // Display results.
        if (activityGroups != null) {
          foreach (ActivityGroup activityGroup in activityGroups) {
            Console.WriteLine("An activity group with ID \"{0}\" and name \"{1}\" was created.",
                activityGroup.id, activityGroup.name);
          }
        } else {
          Console.WriteLine("No activity groups were created.");
        }
      } catch (Exception e) {
        Console.WriteLine("Failed to create activity groups. Exception says \"{0}\"", e.Message);
      }
    }
        /// <summary>
        /// Run the code example.
        /// </summary>
        /// <param name="user">The DFP user object running the code example.</param>
        public override void Run(DfpUser user)
        {
            // Get the ActivityGroupService.
            ActivityGroupService activityGroupService =
                (ActivityGroupService)user.GetService(DfpService.v201311.ActivityGroupService);

            // Set the ID of the activity group and the company to update it with.
            int  activityGroupId     = int.Parse(_T("INSERT_ACTIVITY_GROUP_ID_HERE"));
            long advertiserCompanyId = long.Parse(_T("INSERT_ADVERTISER_COMPANY_ID_HERE"));

            try {
                // Get the activity group.
                ActivityGroup activityGroup = activityGroupService.getActivityGroup(activityGroupId);

                // Update the companies.
                List <long> companyIds = new List <long>(activityGroup.companyIds);
                companyIds.Add(advertiserCompanyId);
                activityGroup.companyIds = companyIds.ToArray();

                // Update the activity groups on the server.
                ActivityGroup[] activityGroups = activityGroupService.updateActivityGroups(
                    new ActivityGroup[] { activityGroup });

                // Display results.
                if (activityGroups != null)
                {
                    foreach (ActivityGroup updatedActivityGroup in activityGroups)
                    {
                        Console.WriteLine("Activity group with ID \"{0}\" and name \"{1}\" was updated.",
                                          updatedActivityGroup.id, updatedActivityGroup.name);
                    }
                }
                else
                {
                    Console.WriteLine("No activity groups were updated.");
                }
            } catch (Exception ex) {
                Console.WriteLine("Failed to update activity groups. Exception says \"{0}\"", ex.Message);
            }
        }
        public IEnumerable <ActivityGroup> Get(int mdBID)
        {
            List <ActivityGroup> actGroupList = new List <ActivityGroup>();
            var conn = _context.Database.GetDbConnection();

            if (conn.State == ConnectionState.Closed)
            {
                conn.Open();
            }

            using (var command = conn.CreateCommand())
            {
                MySql = " SELECT ActGroupID, ActGroupName, IsReflectedInReportCArd, ActGroupReportCard, ActGroupMotive, ActCode, GradeType,"
                        + " Clss, ActSn, ActClss FROM ActivityGroup WITH (NOLOCK)"
                        + " WHERE  Dormant = 0"
                        + " AND dBID = " + mdBID;
                command.CommandType = CommandType.Text;
                command.CommandText = MySql;
                DbDataReader kMyReader = command.ExecuteReader();
                if (kMyReader.HasRows)
                {
                    while (kMyReader.Read())
                    {
                        ActivityGroup actGrp = new ActivityGroup();
                        if (!kMyReader.IsDBNull(0))
                        {
                            actGrp.ActGroupId = kMyReader.GetInt32(0);
                        }
                        if (!kMyReader.IsDBNull(1))
                        {
                            actGrp.ActGroupName = kMyReader.GetString(1);
                        }
                        if (!kMyReader.IsDBNull(2))
                        {
                            actGrp.IsReflectedInReportCard = CIB(kMyReader.GetInt32(2));
                        }
                        if (!kMyReader.IsDBNull(3))
                        {
                            actGrp.ActGroupReportCard = kMyReader.GetString(3);
                        }
                        if (!kMyReader.IsDBNull(4))
                        {
                            actGrp.ActGroupMotive = kMyReader.GetString(4);
                        }
                        if (!kMyReader.IsDBNull(5))
                        {
                            actGrp.ActCode = kMyReader.GetString(5);
                        }
                        if (!kMyReader.IsDBNull(6))
                        {
                            actGrp.GradeType = kMyReader.GetString(6);
                        }
                        if (!kMyReader.IsDBNull(7))
                        {
                            actGrp.Clss = kMyReader.GetString(7);
                        }
                        if (!kMyReader.IsDBNull(8))
                        {
                            actGrp.ActSn = kMyReader.GetInt32(8);
                        }
                        if (!kMyReader.IsDBNull(9))
                        {
                            actGrp.ActClss = kMyReader.GetString(9);
                        }
                        actGroupList.Add(actGrp);
                    }
                }
            }
            //return Json(new { result = acaSessList.Skip(skip).Take(take), count = acaSessList.Count() });
            return(actGroupList);
        }
        public async Task <IActionResult> PutActivityGroup([FromRoute] int id, [FromBody] ActivityGroup activityGroup)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            //if (id != activityGroup.AutoId)
            //{
            //    return BadRequest();
            //}

            _context.Entry(activityGroup).State = EntityState.Modified;

            var actGroupId = id;

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            try
            {
                var conn = _context.Database.GetDbConnection();
                if (conn.State == ConnectionState.Closed)
                {
                    await conn.OpenAsync();
                }
                using (var command = conn.CreateCommand())
                {
                    MySql = " UPDATE ActivityGroup SET ";
                    MySql = MySql + " ActGroupName = '" + activityGroup.ActGroupName + "',";
                    MySql = MySql + " IsReflectedInReportCArd = " + CBI(activityGroup.IsReflectedInReportCard) + ",";
                    MySql = MySql + " ActGroupReportCard = '" + activityGroup.ActGroupReportCard + "',";
                    MySql = MySql + " ActGroupMotive = '" + activityGroup.ActGroupMotive + "',";
                    MySql = MySql + " ActCode = '" + activityGroup.ActCode + "',";
                    MySql = MySql + " GradeType = '" + activityGroup.GradeType + "',";
                    MySql = MySql + " Clss = '" + activityGroup.ActClss + "',";
                    MySql = MySql + " ActSn = " + activityGroup.ActSn + ",";
                    MySql = MySql + " ActClss = '" + activityGroup.ActClss + "'";
                    MySql = MySql + " WHERE ActGroupId = " + activityGroup.ActGroupId;
                    MySql = MySql + " AND Dormant = 0";
                    MySql = MySql + " AND dBID = " + activityGroup.DBid;
                    //MySql = MySql + " AND AcaSession = '" + activityGroup.ActSession + "'";

                    command.CommandType = CommandType.Text;
                    command.CommandText = MySql;
                    command.ExecuteNonQuery();
                }
                //await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ActivityGroupExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public static ICollection<StockInformation> GetAvailableStock(ICollection<StockInformation> stockInformations, ICollection<ApprovedDetail> approvedDetails,ActivityGroup activityGroup,Manufacturer manufacturer,PhysicalStore physicalStore,DateTime? expiryDate)
        {
            var approvedDetailClone = approvedDetails.Select(a => new ApprovedDetail(a)).ToList();
           
            var nonPreferredStockInformation = stockInformations
                .Where(s => ((activityGroup != null && activityGroup.ActivityGroupID != s.Activity.ActivityGroupID)
                             || ((manufacturer != null) && (manufacturer.ManufacturerID != s.Manufacturer.ManufacturerID))
                             || (physicalStore != null && (physicalStore.PhysicalStoreID != s.PhysicalStore.PhysicalStoreID))
                             || (expiryDate != null && expiryDate != s.ExpiryDate))).Select(s => new StockInformation(s)).ToList();

            SubstractApprovedQuantityFromStock(nonPreferredStockInformation, approvedDetailClone);


            //Substract Then From Preferred if Non Prefered cannot satisfy approvedDetail
            
            var preferredStockInformation = stockInformations
                .Where(s => ((activityGroup == null     || activityGroup.ActivityGroupID == s.Activity.ActivityGroupID)
                             && ((manufacturer == null) || ( manufacturer.ManufacturerID == s.Manufacturer.ManufacturerID))
                             && (physicalStore == null  ||  ( physicalStore.PhysicalStoreID == s.PhysicalStore.PhysicalStoreID))
                             && (expiryDate == null     || expiryDate == s.ExpiryDate))).Select(s=> new StockInformation(s)).ToList();

            SubstractApprovedQuantityFromStock(preferredStockInformation, approvedDetailClone);

            return preferredStockInformation;
        }
Example #26
0
        public async Task <IActionResult> Move([FromBody] Messages.ActivityGroupMoveRequest request)
        {
            // Validate that the user is logged in.
            var account = await GetCurrentAccountAsync();

            if (account == null)
            {
                return(Unauthorized());
            }

            // Basic validation.
            if (request.Id != null && !string.IsNullOrWhiteSpace(request.MatchResponseText))
            {
                return(BadRequest("Should not provide both 'id' and 'matchResponseText'"));
            }
            else if (request.Id == null && string.IsNullOrWhiteSpace(request.MatchResponseText))
            {
                return(BadRequest("Must provide either 'id' or 'matchResponseText'"));
            }

            var nameError = ValidateLength(request.MatchResponseText, ActivityGroup.MaxMatchResponseTextLength, "matchResponseText");

            if (nameError != null)
            {
                return(nameError);
            }

            var parentError = ValidateParentDescription(request.TargetParentId,
                                                        request.TargetParentMatchResponseText,
                                                        request.TargetGrandparentId,
                                                        "targetParent");

            if (parentError != null)
            {
                return(parentError);
            }

            if (request.TargetIsUncategorized != null &&
                (request.TargetParentId != null || !string.IsNullOrWhiteSpace(request.TargetParentMatchResponseText)))
            {
                return(BadRequest("Cannot provide 'targetIsUncategorized' when providing target parent details."));
            }

            if (!string.IsNullOrWhiteSpace(request.MatchResponseText) &&
                request.MatchResponseText == request.TargetParentMatchResponseText)
            {
                return(BadRequest("'matchResponseText' and 'targetParentMatchResponseText' cannot be the same. " +
                                  "Cannot make an activity group its own parent."));
            }

            // Data validation.
            Poll          poll          = null;
            ActivityGroup activityGroup = null;

            if (request.Id != null)
            {
                // This should be an actual activity group. Check if it exists.
                activityGroup = await Db.ActivityGroups.FirstOrDefaultAsync(g => g.Id == request.Id);

                if (activityGroup == null)
                {
                    return(NotFound($"Could not find ActivityGroup with id = {request.Id}"));
                }

                var pollId = activityGroup.PollId;
                poll = await Db.Polls.FirstOrDefaultAsync(p => p.Id == pollId);

                if (poll == null)
                {
                    throw new Exception($"Could not find a poll wit Id {pollId}");
                }
                else if (poll.AccountId != account.Id)
                {
                    return(NotFound($"Could not find ActivityGroup with id = {request.Id}"));
                }
            }
            else
            {
                // Confirm that this ActivityGroup does not exist.
                poll = await GetDefaultPollAsync();

                var existingGroup = await Db.ActivityGroups.FirstOrDefaultAsync(g => g.PollId == poll.Id &&
                                                                                g.MatchResponseText == request.MatchResponseText);

                if (existingGroup != null)
                {
                    return(BadRequest("There is already an ActivityGroup with matchResponseText = " +
                                      $"'{request.MatchResponseText}'. Its id is {existingGroup.Id}. Please target it by its id."));
                }

                // Create the activity group.
                activityGroup = new ActivityGroup
                {
                    Id   = Guid.NewGuid(),
                    Name = request.MatchResponseText,
                    MatchResponseText = request.MatchResponseText,
                    PollId            = poll.Id,
                    Position          = 0
                };

                Db.ActivityGroups.Add(activityGroup);
            }

            var parentExistsError = await ValidateGroupExists(poll,
                                                              request.TargetParentId,
                                                              request.TargetParentMatchResponseText,
                                                              request.TargetGrandparentId,
                                                              "target parent");

            if (parentExistsError != null)
            {
                return(parentExistsError);
            }

            // Make sure that this ActivityGroup will not be its own ancestor.
            var nextAncestorId = request.TargetParentId;

            while (nextAncestorId.HasValue)
            {
                var ancestor = await Db.ActivityGroups.FirstAsync(g => g.PollId == poll.Id && g.Id == nextAncestorId.Value);

                if (ancestor == null)
                {
                    break;
                }

                if (ancestor.Id == request.Id)
                {
                    return(BadRequest("Cannot make make ActivityGroup its own ancestor."));
                }

                nextAncestorId = ancestor.ParentId;
            }

            // User tracking.
            await UserEventsService.RecordEvent(new UserEvent
            {
                Account  = Account,
                Category = "activity_group",
                Name     = "move"
            });

            // Perform the move.
            if (request.TargetParentId == null && string.IsNullOrEmpty(request.TargetParentMatchResponseText))
            {
                // Move to the top level.
                activityGroup.ParentId = null;
            }
            else if (request.TargetParentId != null)
            {
                // Move it under the parent.
                activityGroup.ParentId = request.TargetParentId;
            }
            else if (!string.IsNullOrEmpty(request.TargetParentMatchResponseText))
            {
                // Create the target parent.
                var parent = new ActivityGroup
                {
                    Id   = Guid.NewGuid(),
                    Name = request.TargetParentMatchResponseText,
                    MatchResponseText = request.TargetParentMatchResponseText,
                    PollId            = poll.Id,
                    Position          = 0
                };

                if (request.TargetGrandparentId != null)
                {
                    parent.ParentId = request.TargetGrandparentId;
                }

                Db.ActivityGroups.Add(parent);
                activityGroup.ParentId = parent.Id;
            }
            else
            {
                // We should not enter here.
                throw new Exception("Reached unreacheable code in " + nameof(ActivityGroupsController) + ".Move().");
            }

            await Db.SaveChangesAsync();

            return(NoContent());
        }
Example #27
0
        public ActionResult UploadData(string Filename)
        {
            Boolean IsSuccess      = false;
            string  strMessage     = string.Empty;
            string  UploadLoanPath = Server.MapPath("~/Content/UploadData/" + Filename);
            var     i = 6;

            try
            {
                FileStream     file           = new FileStream(UploadLoanPath, FileMode.Open, FileAccess.Read);
                ExcelPackage   ExcelPackage   = new ExcelPackage(file);
                ExcelWorksheet ExcelWorksheet = ExcelPackage.Workbook.Worksheets["Sheet1"];
                try
                {
                    var hasValue = true;

                    int    tahun     = Convert.ToInt32(ExcelWorksheet.Cells[1, 3].Text.Trim());
                    string fungsi    = ExcelWorksheet.Cells[2, 3].Text.Trim();
                    string jabatan   = ExcelWorksheet.Cells[3, 3].Text.Trim();
                    var    wlaheader = db.WLAHeaders.Where(s => s.Tahun == tahun && s.Fungsi.Name.Equals(fungsi) && s.Jabatan.Name.Equals(jabatan)).First();
                    if (wlaheader == null)
                    {
                        WLAHeader x = new WLAHeader();
                        x.Tahun   = tahun;
                        x.Fungsi  = db.Fungsi.Where(c => c.Name.Equals(fungsi)).First();
                        x.Jabatan = db.Jabatan.Where(c => c.Name.Equals(jabatan)).First();
                        db.WLAHeaders.Add(x);
                        db.SaveChanges();
                        wlaheader = db.WLAHeaders.Where(s => s.Tahun == tahun && s.Fungsi.Name.Equals(fungsi) && s.Jabatan.Name.Equals(jabatan)).First();
                    }
                    //Looping data dr excel
                    string current_grup = "";
                    while (hasValue)
                    {
                        WLATrx wLATrx = new WLATrx();
                        if (string.IsNullOrEmpty(ExcelWorksheet.Cells[i, 3].Text))
                        {
                            hasValue = false;
                            continue;
                        }

                        string activity_s = ExcelWorksheet.Cells[i, 3].Text.Trim();
                        var    activity   = db.Activities.Where(s => s.Name.Equals(activity_s)).FirstOrDefault();
                        if (activity == null)
                        {
                            Activity x = new Activity();
                            x.Name = activity_s;
                            db.Activities.Add(x);
                            db.SaveChanges();
                            activity = db.Activities.Where(s => s.Name.Equals(activity_s)).First();
                        }
                        wLATrx.Activity = activity;

                        string activityGroup_s = ExcelWorksheet.Cells[i, 2].Text.Trim();
                        if (activityGroup_s.Equals(""))
                        {
                            activityGroup_s = current_grup;
                        }
                        else
                        {
                            current_grup = activityGroup_s;
                        }
                        var activityGroup = db.ActivityGroups.Where(s => s.Name.Equals(activityGroup_s)).FirstOrDefault();
                        if (activityGroup == null)
                        {
                            ActivityGroup x = new ActivityGroup();
                            x.Name = activityGroup_s;
                            db.ActivityGroups.Add(x);
                            db.SaveChanges();
                            activityGroup = db.ActivityGroups.Where(s => s.Name.Equals(activityGroup_s)).First();
                        }
                        wLATrx.ActivityGroup = activityGroup;

                        string pelaksana = ExcelWorksheet.Cells[i, 4].Text.Trim();
                        wLATrx.Pelaksana = db.Pelaksana.Where(c => c.Name.Equals(pelaksana)).FirstOrDefault();
                        if (wLATrx.Pelaksana == null)
                        {
                            strMessage = strMessage + "row " + i + " gagal, ";
                            i++;
                            continue;
                        }

                        string periode = ExcelWorksheet.Cells[i, 5].Text.Trim();
                        wLATrx.Periode = db.Periode.Where(c => c.Name.Equals(periode)).FirstOrDefault();
                        if (wLATrx == null)
                        {
                            strMessage = strMessage + "row " + i + " gagal, ";
                            i++;
                            continue;
                        }

                        int      Periode_Value = 0;
                        WLAModel wm            = new WLAModel();
                        Periode_Value              = wm.getPeriode(wLATrx.Periode.Id);
                        wLATrx.WLAHeader           = wlaheader;
                        wLATrx.Process_Time        = Convert.ToInt32(ExcelWorksheet.Cells[i, 6].Text.Trim());
                        wLATrx.Quantity            = Convert.ToInt32(ExcelWorksheet.Cells[i, 7].Text.Trim());
                        wLATrx.Frequency           = Convert.ToInt32(ExcelWorksheet.Cells[i, 8].Text.Trim());
                        wLATrx.Sub_Total_Aktivitas = (double)(Periode_Value * wLATrx.Process_Time * wLATrx.Quantity * wLATrx.Frequency) / 60;
                        var wlaExist = db.WLATrx.Where(
                            s => s.WLAHeader.Id == wlaheader.Id &&
                            s.Activity.Name.Equals(activity_s) &&
                            s.ActivityGroup.Name.Equals(activityGroup_s)
                            ).FirstOrDefault();
                        if (wlaExist == null)
                        {
                            db.WLATrx.Add(wLATrx);
                        }
                        else
                        {
                            wlaExist.Frequency           = wLATrx.Frequency;
                            wlaExist.Process_Time        = wLATrx.Process_Time;
                            wlaExist.Quantity            = wLATrx.Quantity;
                            wlaExist.Sub_Total_Aktivitas = wLATrx.Sub_Total_Aktivitas;
                        }

                        db.SaveChanges();

                        var standardTime = db.Standard_Time.Where(d => d.Tahun == tahun).FirstOrDefault();
                        if (standardTime != null)
                        {
                            var Sub_Total_Aktivitas = db.WLATrx.Where(d => d.WLAHeader.Id == wlaheader.Id).Sum(d => d.Sub_Total_Aktivitas);
                            var dataHeader          = db.WLAHeaders.Find(wlaheader.Id);
                            dataHeader.Effective_Working_Hours = Sub_Total_Aktivitas;
                            dataHeader.FTE = Sub_Total_Aktivitas / standardTime.Effective_Working_Hours;
                            db.SaveChanges();
                        }

                        i++;
                    }
                }
                catch (Exception e)
                {
                    strMessage = "" + i;
                    file.Close();
                    file.Dispose();
                    throw new Exception(e.Message);
                }

                IsSuccess = true;

                file.Close();
                file.Dispose();
            }
            catch (Exception e)
            {
                strMessage = "" + i;
                throw new Exception(e.Message);
            }
            return(Json(new
            {
                status = IsSuccess,
                message = strMessage
            }, JsonRequestBehavior.AllowGet));
        }
Example #28
0
        public async Task <IActionResult> Create([FromBody] Messages.ActivityGroupCreateRequest request)
        {
            // Validate that the user is logged in.
            var account = await GetCurrentAccountAsync();

            if (account == null)
            {
                return(Unauthorized());
            }

            // Basic validation.
            var nameError = ValidateName(request.Name);

            if (nameError != null)
            {
                return(nameError);
            }

            var parentError = ValidateParentDescription(request.ParentId,
                                                        request.ParentMatchResponseText,
                                                        request.GrandparentId,
                                                        "parent");

            if (parentError != null)
            {
                return(parentError);
            }

            // Data validation.
            var poll = await GetDefaultPollAsync();

            var parentExistsError = await ValidateGroupExists(poll,
                                                              request.ParentId,
                                                              request.ParentMatchResponseText,
                                                              request.GrandparentId,
                                                              "parent");

            if (parentExistsError != null)
            {
                return(parentExistsError);
            }

            // User tracking.
            await UserEventsService.RecordEvent(new UserEvent
            {
                Account  = Account,
                Category = "activity_group",
                Name     = "create"
            });

            // Create.
            var newGroup = new ActivityGroup
            {
                Id       = Guid.NewGuid(),
                ParentId = request.ParentId,
                Name     = request.Name,
                PollId   = poll.Id,
                Position = 0,
            };

            if (!string.IsNullOrWhiteSpace(request.ParentMatchResponseText))
            {
                var newParent = new ActivityGroup
                {
                    Id                = Guid.NewGuid(),
                    ParentId          = request.GrandparentId,
                    Name              = request.ParentMatchResponseText,
                    MatchResponseText = request.ParentMatchResponseText,
                    Position          = 0,
                    PollId            = poll.Id
                };

                newGroup.ParentId = newParent.Id;
                Db.ActivityGroups.Add(newParent);
            }

            Db.ActivityGroups.Add(newGroup);
            await Db.SaveChangesAsync();

            return(NoContent());
        }
Example #29
0
        public ActionResult Index()
        {
            // user is logged in
            var user = repository.GetUserById(sessionid.Value, subdomainid.Value);

            // check if account has been setup properly
            if (role.HasFlag(UserRole.CREATOR) && !MASTERdomain.currency.HasValue)
            {
                return(RedirectToAction("setup", "register", new { Area = "" }));
            }

            var activityGroups = new ActivityGroup
            {
                tradelr = new TradelrActivity()
                {
                    filterList =
                        typeof(ActivityType).ToSelectList().ToFilterList()
                }
            };

            if (role.HasFlag(UserRole.CREATOR))
            {
                // for admin
                // tradelr activity
                activityGroups.tradelr.activities = repository.GetActivities(subdomainid.Value)
                                                    .OrderByDescending(x => x.id)
                                                    .ToAdminList(sessionid.Value)
                                                    .Take(GeneralConstants.ACTIVITY_ROWS_PER_PAGE)
                                                    .ToModel();
            }
            else
            {
                // for user
                activityGroups.tradelr.activities =
                    repository.GetActivities(subdomainid.Value)
                    .OrderByDescending(x => x.id)
                    .ToUserList(sessionid.Value)
                    .Take(GeneralConstants.ACTIVITY_ROWS_PER_PAGE)
                    .ToModel();
            }


            // handle statistics
            if (role == UserRole.USER)
            {
                // show account stats
                Statistics statistics = null;
                if (baseviewmodel.permission.HasFlag(UserPermission.NETWORK_STORE | UserPermission.TRANSACTION_VIEW | UserPermission.INVENTORY_VIEW))
                {
                    var analytics = new GoogleAnalytics();
                    analytics.GetVisitorStatistics(accountHostname, DateTime.UtcNow.AddMonths(-1), DateTime.UtcNow);
                    statistics = new Statistics(analytics.stats, DateTime.UtcNow.AddMonths(-1), DateTime.UtcNow);
                    statistics.InitSalesAndProductsStatistics(repository, subdomainid.Value, sessionid.Value,
                                                              user.organisation1.MASTERsubdomain);
                }

                // this is for scenario where user is not registered but someone has send them
                // an invoice or purchase order
                var home = new HomeViewData(baseviewmodel)
                {
                    activities = activityGroups,
                    isAdmin    = false,
                    stats      = statistics
                };

                return(View(home));
            }
            else // for admins, god and staff
            {
                // which activity panel?
                var paneltype = repository.GetActivityPanel(sessionid.Value);

                var analytics = new GoogleAnalytics();
                analytics.GetVisitorStatistics(accountHostname, DateTime.UtcNow.AddMonths(-1), DateTime.UtcNow);
                var statistics = new Statistics(analytics.stats, DateTime.UtcNow.AddMonths(-1), DateTime.UtcNow);
                statistics.InitSalesAndProductsStatistics(repository, subdomainid.Value, sessionid.Value,
                                                          user.organisation1.MASTERsubdomain);

                var home = new HomeViewData(baseviewmodel)
                {
                    stats      = statistics, // from baseController
                    activities = activityGroups,
                    panelIndex = paneltype.ToIndex(),
                    isAdmin    = true
                };

                return(View(home));
            }
        }
Example #30
0
 public ActivityViewModel(ActivityGroup activity)
 {
     ActivityID = activity.ActivityGroupID;
     Name       = activity.Name;
 }