public static async Task AddStuentToClassTableAsync(string subjectsTableName, UserRequest newUserRequest, OperationResult response)
        {
            var table = CloudTableUtilities.OpenTable(subjectsTableName);

            if (table == null)
            {
                response.UpdateFailure(ErrorMessages.subjectTableNotExist);
                response.requestSucceeded = false;
                return;
            }

            SubjectsTable newIsInsideTheBagEntity = new SubjectsTable();
            SubjectsTable newStickersEntity       = new SubjectsTable();
            var           classSubjectsEntity     = CloudTableUtilities.getTableEntityAsync <SubjectsTable>(table, ClassSubjects).Result.First();
            var           classSubjectsProperties = typeof(SubjectsTable).GetProperties().Where(x => x.Name.Contains(SubjectPropertyPrefix) && x.GetValue(classSubjectsEntity, null) != null);

            foreach (var classSubjectProperty in classSubjectsProperties)
            {
                classSubjectProperty.SetValue(newIsInsideTheBagEntity, NotInsideTheBag);
            }

            await CloudTableUtilities.AddTableEntity(table, newIsInsideTheBagEntity, newUserRequest.userId, IsInsideTheBag);

            await CloudTableUtilities.AddTableEntity(table, newStickersEntity, newUserRequest.userId, Stickers);
        }
        public static void AddNewSubject(SubjectRequest addSubjectRequest, SubjectsTable classSubjectsNamesEntity, SubjectsTable classSubjectsNecessityEntity, OperationResult operationResult)
        {
            var subjectsWithoutValues = typeof(SubjectsTable).GetProperties().Where(x => x.Name.Contains(SubjectPropertyPrefix) && x.GetValue(classSubjectsNamesEntity, null) == null);

            if (!subjectsWithoutValues.Any())
            {
                operationResult.UpdateFailure(ErrorMessages.noSubjectsAvailable);
            }
            else
            {
                var subject = subjectsWithoutValues.First();
                subject.SetValue(classSubjectsNamesEntity, addSubjectRequest.subjectName);
                subject.SetValue(classSubjectsNecessityEntity, NotNeededSubject);
            }
        }
        public static async void CreateClassTable(string tableName)
        {
            var subjectsTable = await CloudTableUtilities.CreateTableAsync(tableName);

            var            classSubjectsNamesEntity = new SubjectsTable();
            TableOperation insertOperation          = TableOperation.InsertOrReplace(classSubjectsNamesEntity);

            classSubjectsNamesEntity.PartitionKey = ClassSubjects;
            classSubjectsNamesEntity.RowKey       = ClassSubjects;
            await subjectsTable.ExecuteAsync(insertOperation);

            var classSubjectsNecessityEntity = new SubjectsTable();

            insertOperation = TableOperation.InsertOrReplace(classSubjectsNecessityEntity);
            classSubjectsNecessityEntity.PartitionKey = Necessity;
            classSubjectsNecessityEntity.RowKey       = Necessity;
            await subjectsTable.ExecuteAsync(insertOperation);
        }
        public static void UpdateSubjectNecessity(SubjectsTable classSubjectsNamesEntity, SubjectsTable classSubjectsNecessityEntity, List <string> neededSubjects)
        {
            var operationReslut = new OperationResult();

            var subjectsNameToValueMapping = typeof(SubjectsTable).GetProperties().Where(x => x.Name.Contains(SubjectPropertyPrefix) && x.GetValue(classSubjectsNamesEntity, null) != null).ToDictionary(prop => prop.Name, prop => prop.GetValue(classSubjectsNamesEntity, null).ToString());

            foreach (var subjectMappingPair in subjectsNameToValueMapping)
            {
                if (neededSubjects.Contains(subjectMappingPair.Value))
                {
                    typeof(SubjectsTable).GetProperty(subjectMappingPair.Key).SetValue(classSubjectsNecessityEntity, NeededSubject);
                }
                else
                {
                    typeof(SubjectsTable).GetProperty(subjectMappingPair.Key).SetValue(classSubjectsNecessityEntity, NotNeededSubject);
                }
            }
        }
        public static async Task RenameSubjectAsync(SubjectRequest editSubjectRequest, SubjectsTable subjectsNames, string scheduleTableName, SubjectsTable subjectsNecessity, OperationResult operationResult)
        {
            var subjects = typeof(SubjectsTable).GetProperties().Where(x => string.Equals(x.GetValue(subjectsNames, null)?.ToString(), editSubjectRequest.subjectName));

            if (!subjects.Any())
            {
                operationResult.UpdateFailure(ErrorMessages.subjetNotFound);
            }
            else
            {
                subjects.First().SetValue(subjectsNames, editSubjectRequest.newSubjectName);
            }

            if (scheduleTableName != null)
            {
                var scheduleTable = CloudTableUtilities.OpenTable(scheduleTableName);
                var daysEntities  = CloudTableUtilities.getTableEntityAsync <ScheduleTable>(scheduleTable).Result;

                foreach (var dayEntity in daysEntities)
                {
                    var daySubjects = typeof(ScheduleTable).GetProperties().Where(x => x.Name.Contains(SubjectPropertyPrefix) && x.GetValue(dayEntity, null) != null).ToList();

                    foreach (var subjectProperty in daySubjects)
                    {
                        if (subjectProperty.GetValue(dayEntity, null).ToString() == editSubjectRequest.subjectName)
                        {
                            subjectProperty.SetValue(dayEntity, editSubjectRequest.newSubjectName);
                        }
                    }

                    await CloudTableUtilities.AddTableEntity(scheduleTable, dayEntity);
                }
            }
        }