admin/WerkoutIOS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add apple tv app

Browse Source
This commit is contained in:
Trey t
2024-06-18 12:03:56 -05:00
parent addeca4ead
commit 7d2b6b3e6e
134 changed files with 869 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
iphone/Werkout_ios/Views/AccountView/AccountView.swift Normal file
View File

@@ -0,0 +1,45 @@
//
// AccountView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/15/23.
//
import Foundation
import SwiftUI
struct AccountView: View {
@ObservedObject var userStore = UserStore.shared
var body: some View {
VStack(alignment: .leading) {
NameView()
CompletedWorkoutsView()
Divider()
ThotPreferenceView()
ShowNextUpView()
Spacer()
Logoutview()
}
.padding()
}
}
//struct AccountView_Previews: PreviewProvider {
// static let userStore = UserStore.shared
// static let completedWorkouts = PreviewData.parseCompletedWorkouts()
//
// static var previews: some View {
// AccountView(completedWorkouts: completedWorkouts)
// .onAppear{
// userStore.setFakeUser()
// }
// }
//}

95
iphone/Werkout_ios/Views/AddExercise/AddExerciseView.swift Normal file
View File

@@ -0,0 +1,95 @@
//
// CreateWorkout.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/15/23.
//
import Foundation
import SwiftUI
import Combine
struct AddExerciseView: View {
enum CreateWorkoutItemPickerViewType {
case muscles
case equipment
}
@State var selectedMuscles = [Muscle]()
@State var selectedEquipment = [Equipment]()
@State var filteredExercises = [Exercise]()
@StateObject var bridgeModule = BridgeModule.shared
let selectedExercise: ((Exercise) -> Void)
var body: some View {
VStack {
AllExerciseView(filteredExercises: $filteredExercises,
selectedExercise: { excercise in
selectedExercise(excercise)
})
.padding(.top)
HStack {
AllMusclesView(selectedMuscles: $selectedMuscles)
.frame(maxWidth: .infinity)
Divider()
AllEquipmentView(selectedEquipment: $selectedEquipment)
.frame(maxWidth: .infinity)
}
.padding(.top)
.frame(height: 44)
}
.onChange(of: selectedMuscles, perform: { _ in
filterExercises()
}) .onChange(of: selectedEquipment, perform: { _ in
filterExercises()
})
}
func filterExercises() {
guard let exercises = DataStore.shared.allExercise else {
filteredExercises = []
return
}
let filtered = exercises.filter({ exercise in
var hasCorrectMuscles = false
if selectedMuscles.count == 0 {
hasCorrectMuscles = true
} else {
let exerciseMuscleIds = exercise.muscles.map({ $0.muscle ?? -1 })
let selctedMuscleIds = selectedMuscles.map({ $0.id })
// if one items match
if exerciseMuscleIds.contains(where: selctedMuscleIds.contains) {
// if all items match
hasCorrectMuscles = true
}
}
var hasCorrectEquipment = false
if selectedEquipment.count == 0 {
hasCorrectEquipment = true
} else {
let exerciseEquipmentIds = exercise.equipment.map({ $0.equipment ?? -1 })
let selctedEquipmentIds = selectedEquipment.map({ $0.id })
// if one items match
if exerciseEquipmentIds.contains(where: selctedEquipmentIds.contains) {
// if all items match
hasCorrectEquipment = true
}
}
return hasCorrectMuscles && hasCorrectEquipment
})
filteredExercises = filtered
}
}
//struct AddExerciseView_Previews: PreviewProvider {
// static var previews: some View {
// AddExerciseView(selectedExercise: { _ in })
// }
//}

161
iphone/Werkout_ios/Views/AllWorkouts/AllWorkoutsListView.swift Normal file
View File

@@ -0,0 +1,161 @@
//
// AllWorkoutsListView.swift
// Werkout_ios
//
// Created by Trey Tartt on 7/7/23.
//
import SwiftUI
struct AllWorkoutsListView: View {
enum SortType: String, CaseIterable {
case name = "Name"
case date = "Date"
}
@State var searchString: String = ""
@Binding var uniqueWorkoutUsers: [RegisteredUser]?
@State private var filteredRegisterdUser: RegisteredUser?
let workouts: [Workout]
let selectedWorkout: ((Workout) -> Void)
@State var filteredWorkouts = [Workout]()
var refresh: (() -> Void)
@State var currentSort: SortType?
var body: some View {
VStack {
if let filteredRegisterdUser = filteredRegisterdUser {
Text((filteredRegisterdUser.firstName ?? "NA") + "'s Workouts")
}
ScrollView {
LazyVStack(spacing: 20) {
ForEach(filteredWorkouts, id:\.id) { workout in
WorkoutOverviewView(workout: workout)
.padding([.leading, .trailing])
.contentShape(Rectangle())
.onTapGesture {
selectedWorkout(workout)
}
}
}
}
.refreshable {
refresh()
}
HStack {
TextField("Filter" ,text: $searchString)
.padding()
.textFieldStyle(OvalTextFieldStyle())
if let uniqueWorkoutUsers = uniqueWorkoutUsers {
Menu(content: {
ForEach(uniqueWorkoutUsers, id: \.self) { index in
Button(action: {
filteredRegisterdUser = index
filteredWorkouts = filterWorkouts()
}, label: {
Text((index.firstName ?? "") + " -" + (index.lastName ?? ""))
})
}
Button(action: {
filteredRegisterdUser = nil
filteredWorkouts = filterWorkouts()
}, label: {
Text("All")
})
}, label: {
Image(systemName: filteredRegisterdUser == nil ? "person.2" : "person.2.fill")
.padding(.trailing)
})
}
Menu(content: {
ForEach(SortType.allCases, id: \.self) { index in
Button(action: {
sortWorkouts(sortType: index)
}, label: {
Text(index.rawValue)
})
}
}, label: {
Image(systemName: "list.number")
.padding(.trailing)
})
}
}
.onChange(of: searchString) { newValue in
filteredWorkouts = filterWorkouts()
}
.onAppear{
filteredWorkouts = filterWorkouts()
}
}
func sortWorkouts(sortType: SortType) {
if currentSort == sortType {
filteredWorkouts = filteredWorkouts.reversed()
return
}
switch sortType {
case .name:
filteredWorkouts = filteredWorkouts.sorted(by: {
$0.name < $1.name
})
case .date:
filteredWorkouts = filteredWorkouts.sorted(by: {
$0.createdAt ?? Date() < $1.createdAt ?? Date()
})
}
currentSort = sortType
}
func filterWorkouts() -> [Workout] {
var matchingWorkouts = [Workout]()
if (!searchString.isEmpty && searchString.count > 0) {
matchingWorkouts = workouts.filter({
if $0.name.lowercased().contains(searchString.lowercased()) {
return true
}
if let equipment = $0.equipment?.joined(separator: "").lowercased(),
equipment.contains(searchString.lowercased()) {
return true
}
if let muscles = $0.muscles?.joined(separator: "").lowercased(),
muscles.contains(searchString.lowercased()) {
return true
}
return false
})
}
if matchingWorkouts.isEmpty {
matchingWorkouts.append(contentsOf: workouts)
}
if let filteredRegisterdUser = filteredRegisterdUser {
matchingWorkouts = matchingWorkouts.filter({
$0.registeredUser == filteredRegisterdUser
})
}
return matchingWorkouts
}
}
struct AllWorkoutsListView_Previews: PreviewProvider {
static var previews: some View {
AllWorkoutsListView(uniqueWorkoutUsers: .constant([]),
workouts: PreviewData.allWorkouts(),
selectedWorkout: { workout in },
refresh: { })
}
}

204
iphone/Werkout_ios/Views/AllWorkouts/AllWorkoutsView.swift Normal file
View File

@@ -0,0 +1,204 @@
//
// AllWorkoutsView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/15/23.
//
import Foundation
import SwiftUI
import HealthKit
enum MainViewTypes: Int, CaseIterable {
case AllWorkout = 0
case MyWorkouts
var title: String {
switch self {
case .AllWorkout:
return "All Workouts"
case .MyWorkouts:
return "Planned Workouts"
}
}
}
struct AllWorkoutsView: View {
@State var isUpdating = false
@State var workouts: [Workout]?
@State var uniqueWorkoutUsers: [RegisteredUser]?
let healthStore = HKHealthStore()
var bridgeModule = BridgeModule.shared
@State public var needsUpdating: Bool = true
@ObservedObject var dataStore = DataStore.shared
@State private var showWorkoutDetail = false
@State private var selectedWorkout: Workout? {
didSet {
bridgeModule.currentExerciseInfo.workout = selectedWorkout
}
}
@State private var selectedPlannedWorkout: Workout? {
didSet {
bridgeModule.currentExerciseInfo.workout = selectedPlannedWorkout
}
}
@State private var showLoginView = false
@State private var selectedSegment: MainViewTypes = .AllWorkout
@State var selectedDate: Date = Date()
let pub = NotificationCenter.default.publisher(for: NSNotification.Name("CreatedNewWorkout"))
var body: some View {
ZStack {
if let workouts = workouts {
VStack {
AllWorkoutPickerView(mainViews: MainViewTypes.allCases,
selectedSegment: $selectedSegment,
showCurrentWorkout: {
selectedWorkout = bridgeModule.currentExerciseInfo.workout
})
switch selectedSegment {
case .AllWorkout:
if isUpdating {
ProgressView()
.progressViewStyle(.circular)
}
AllWorkoutsListView(uniqueWorkoutUsers: $uniqueWorkoutUsers,
workouts: workouts,
selectedWorkout: { workout in
selectedWorkout = workout
}, refresh: {
self.needsUpdating = true
maybeUpdateShit()
})
Divider()
case .MyWorkouts:
plannedWorkout(workouts: UserStore.shared.plannedWorkouts)
}
}
} else {
ProgressView("Updating")
}
}.onAppear{
// UserStore.shared.logout()
authorizeHealthKit()
maybeUpdateShit()
}
.sheet(item: $selectedWorkout) { item in
var isPreview = item.id == bridgeModule.currentExerciseInfo.workout?.id
let viewModel = WorkoutDetailViewModel(workout: item, isPreview: isPreview)
WorkoutDetailView(viewModel: viewModel)
}
.sheet(item: $selectedPlannedWorkout) { item in
let viewModel = WorkoutDetailViewModel(workout: item, isPreview: true)
WorkoutDetailView(viewModel: viewModel)
}
.sheet(isPresented: $showLoginView) {
LoginView(completion: {
self.needsUpdating = true
maybeUpdateShit()
})
.interactiveDismissDisabled()
}
.onReceive(pub) { (output) in
self.needsUpdating = true
maybeUpdateShit()
}
}
func plannedWorkout(workouts: [PlannedWorkout]) -> some View {
List {
ForEach(workouts, id:\.workout.name) { plannedWorkout in
HStack {
VStack(alignment: .leading) {
Text(plannedWorkout.onDate.plannedDate?.weekDay ?? "-")
.font(.title)
Text(plannedWorkout.onDate.plannedDate?.monthString ?? "-")
.font(.title)
Text(plannedWorkout.onDate.plannedDate?.dateString ?? "-")
.font(.title)
}
Divider()
VStack {
Text(plannedWorkout.workout.name)
.font(.title)
.frame(maxWidth: .infinity, alignment: .leading)
Text(plannedWorkout.workout.description ?? "")
.font(.body)
.frame(maxWidth: .infinity, alignment: .leading)
Text(plannedWorkout.onDate)
.font(.footnote)
.frame(maxWidth: .infinity, alignment: .leading)
}
.contentShape(Rectangle())
.onTapGesture {
selectedPlannedWorkout = plannedWorkout.workout
}
}
}
}
}
func maybeUpdateShit() {
if UserStore.shared.token != nil{
if UserStore.shared.plannedWorkouts.isEmpty {
UserStore.shared.fetchPlannedWorkouts()
}
if needsUpdating {
self.isUpdating = true
dataStore.fetchAllData(completion: {
DispatchQueue.main.async {
guard let allWorkouts = dataStore.allWorkouts else {
return
}
self.workouts = allWorkouts.sorted(by: {
$0.createdAt ?? Date() < $1.createdAt ?? Date()
})
self.isUpdating = false
self.uniqueWorkoutUsers = dataStore.workoutsUniqueUsers
}
self.isUpdating = false
})
}
} else {
showLoginView = true
}
}
func authorizeHealthKit() {
let healthKitTypes: Set = [
HKObjectType.quantityType(forIdentifier: .heartRate)!,
HKObjectType.quantityType(forIdentifier: .activeEnergyBurned)!,
HKObjectType.quantityType(forIdentifier: .oxygenSaturation)!,
HKQuantityType.workoutType()
]
healthStore.requestAuthorization(toShare: healthKitTypes, read: healthKitTypes) { (succ, error) in
if !succ {
fatalError("Error requesting authorization from health store: \(String(describing: error)))")
}
}
}
}
struct AllWorkoutsView_Previews: PreviewProvider {
static var previews: some View {
AllWorkoutsView(workouts: PreviewData.allWorkouts())
}
}

211
iphone/Werkout_ios/Views/CompletedWorkout/CompletedWorkoutView.swift Normal file
View File

@@ -0,0 +1,211 @@
//
// CompletedWorkoutView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/22/23.
//
import SwiftUI
import HealthKit
struct CompletedWorkoutView: View {
@ObservedObject var bridgeModule = BridgeModule.shared
@State var healthKitWorkoutData: HealthKitWorkoutData?
@State var difficulty: Float = 0
@State var notes: String = ""
@State var isUploading: Bool = false
@State var gettingHealthKitData: Bool = false
var postData: [String: Any]
let healthKitHelper = HealthKitHelper()
let workout: Workout
let completedWorkoutDismissed: ((Bool) -> Void)?
@Environment(\.dismiss) var dismiss
var body: some View {
ZStack {
if isUploading {
ProgressView("Uploading")
}
VStack {
topViews()
Divider()
HStack {
if let calsBurned = healthKitWorkoutData?.caloriesBurned {
HStack {
HStack {
Image(systemName: "flame.fill")
.foregroundColor(.orange)
.font(.title)
VStack {
Text("\(calsBurned, specifier: "%.0f")")
}
}
.frame(maxWidth: .infinity)
}
if let minHeart = healthKitWorkoutData?.minHeartRate,
let maxHeart = healthKitWorkoutData?.maxHeartRate,
let avgHeart = healthKitWorkoutData?.avgHeartRate {
VStack {
HStack {
Image(systemName: "heart")
.foregroundColor(.red)
.font(.title)
VStack {
HStack {
Text("\(minHeart, specifier: "%.0f")")
Text("-")
Text("\(maxHeart, specifier: "%.0f")")
}
Text("\(avgHeart, specifier: "%.0f")")
}
}
}
.frame(maxWidth: .infinity)
}
}
}
rateWorkout()
.frame(maxHeight: 88)
Divider()
TextField("Notes", text: $notes)
.frame(height: 55)
.textFieldStyle(PlainTextFieldStyle())
.padding([.horizontal], 4)
.overlay(RoundedRectangle(cornerRadius: 16).stroke(Color(uiColor: .clear))).background(Color(uiColor: .init(red: 200/255, green: 200/255, blue: 200/255, alpha: 0.2)))
.cornerRadius(8)
if gettingHealthKitData {
ProgressView("Getting HealthKit data")
.padding()
}
Spacer()
Button("Upload", action: {
isUploading = true
upload(postBody: postData)
})
.frame(maxWidth: .infinity, alignment: .center)
.frame(height: 44)
.foregroundColor(.blue)
.background(.yellow)
.cornerRadius(8)
.padding()
.frame(maxWidth: .infinity)
}
.padding([.leading, .trailing])
}
.onAppear{
bridgeModule.sendWorkoutCompleteToWatch()
}
.onChange(of: bridgeModule.healthKitUUID, perform: { healthKitUUID in
if let healthKitUUID = healthKitUUID {
gettingHealthKitData = true
healthKitHelper.getDetails(forHealthKitUUID: healthKitUUID,
completion: { healthKitWorkoutData in
self.healthKitWorkoutData = healthKitWorkoutData
gettingHealthKitData = false
})
}
})
}
func topViews() -> some View {
VStack {
Text(workout.name)
.frame(maxWidth: .infinity, alignment: .leading)
.font(.title3)
.padding(.top
)
if let desc = workout.description {
Text(desc)
.frame(maxWidth: .infinity, alignment: .leading)
.font(.body)
.padding(.top)
}
}
}
func rateWorkout() -> some View {
VStack {
Divider()
HStack {
Text("No Rate")
.foregroundColor(.black)
Text("Easy")
.foregroundColor(.green)
Spacer()
Text("Death")
.foregroundColor(.red)
}
ZStack {
LinearGradient(
gradient: Gradient(colors: [.black, .green, .red]),
startPoint: .leading,
endPoint: .trailing
)
.mask(Slider(value: $difficulty, in: 0...5, step: 1))
// Dummy replicated slider, to allow sliding
Slider(value: $difficulty, in: 0...5, step: 1)
.opacity(0.05) // Opacity is the trick here.
.accentColor(.clear)
}
}
}
func upload(postBody: [String: Any]) {
var _postBody = postBody
_postBody["difficulty"] = difficulty
_postBody["notes"] = notes
if let healthKitUUID = bridgeModule.healthKitUUID {
_postBody["health_kit_workout_uuid"] = healthKitUUID.uuidString
}
CompleteWorkoutFetchable(postData: _postBody).fetch(completion: { result in
switch result {
case .success(_):
DispatchQueue.main.async {
bridgeModule.resetCurrentWorkout()
dismiss()
completedWorkoutDismissed?(true)
}
case .failure(let failure):
DispatchQueue.main.async {
self.isUploading = false
}
print(failure)
}
})
}
}
struct CompletedWorkoutView_Previews: PreviewProvider {
static let postBody = [
"difficulty": 1,
"workout_start_time": Date().timeFormatForUpload,
"workout": 1,
"total_time": 140,
"total_calories": Float(120.0),
"heart_rates": [65,65,4,54,232,12]
] as [String : Any]
static let workout = PreviewData.workout()
static var previews: some View {
CompletedWorkoutView(postData: CompletedWorkoutView_Previews.postBody,
workout: workout,
completedWorkoutDismissed: { _ in })
}
}

111
iphone/Werkout_ios/Views/CreateWorkout/CreateExerciseActionsView.swift Normal file
View File

@@ -0,0 +1,111 @@
//
// CreateViewRepsWeightView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/18/23.
//
import SwiftUI
struct CreateExerciseActionsView: View {
@ObservedObject var workoutExercise: CreateWorkoutExercise
var superset: CreateWorkoutSuperSet
var viewModel: WorkoutViewModel
var body: some View {
VStack {
HStack {
VStack {
VStack {
Text("Reps: ")
Text("\(workoutExercise.reps)")
.foregroundColor(workoutExercise.reps == 0 && workoutExercise.duration == 0 ? .red : Color(uiColor: .label))
.bold()
}
Stepper("", onIncrement: {
workoutExercise.increaseReps()
}, onDecrement: {
workoutExercise.decreaseReps()
})
.labelsHidden()
}
.frame(maxWidth: .infinity)
Divider()
VStack{
VStack {
Text("Weight: ")
Text("\(workoutExercise.weight)")
}
Stepper("", onIncrement: {
workoutExercise.increaseWeight()
}, onDecrement: {
workoutExercise.decreaseWeight()
})
.labelsHidden()
}
.frame(maxWidth: .infinity)
Divider()
VStack{
VStack {
Text("Duration: ")
Text("\(workoutExercise.duration)")
.foregroundColor(workoutExercise.reps == 0 && workoutExercise.duration == 0 ? .red : Color(uiColor: .label))
.bold()
}
Stepper("", onIncrement: {
workoutExercise.increaseDuration()
}, onDecrement: {
workoutExercise.decreaseDuration()
})
}
}
HStack {
Spacer()
Button(action: {
}) {
Image(systemName: "video.fill")
}
.frame(width: 88, height: 44)
.foregroundColor(.white)
.background(.blue)
.cornerRadius(10)
.buttonStyle(BorderlessButtonStyle())
Spacer()
Divider()
Spacer()
Button(action: {
superset.deleteExerciseForChosenSuperset(exercise: workoutExercise)
viewModel.increaseRandomNumberForUpdating()
viewModel.objectWillChange.send()
}) {
Image(systemName: "trash.fill")
}
.frame(width: 88, height: 44)
.foregroundColor(.white)
.background(.red)
.cornerRadius(10)
.buttonStyle(BorderlessButtonStyle())
Spacer()
}
Divider()
.background(.blue)
}
}
}
//struct CreateViewRepsWeightView_Previews: PreviewProvider {
// static var previews: some View {
// CreateViewRepsWeightView()
// }
//}

170
iphone/Werkout_ios/Views/CreateWorkout/CreateViewModels.swift Normal file
View File

@@ -0,0 +1,170 @@
//
// CreateViewModels.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/18/23.
//
import SwiftUI
class CreateWorkoutExercise: ObservableObject, Identifiable {
let id = UUID()
var exercise: Exercise
@Published var reps: Int = 0
@Published var duration: Int = 0
@Published var weight: Int = 0
init(exercise: Exercise, reps: Int = 0, duration: Int = 0, weight: Int = 0) {
self.exercise = exercise
self.reps = reps
self.duration = duration
self.weight = weight
}
func increaseReps() {
self.reps += 1
}
func decreaseReps() {
self.reps -= 1
if self.reps < 0 {
self.reps = 0
}
}
func increaseDuration() {
self.duration += 15
self.reps = 0
}
func decreaseDuration() {
self.duration -= 15
if self.duration < 0 {
self.duration = 0
}
}
func increaseWeight() {
self.weight += 5
}
func decreaseWeight() {
self.weight -= 15
if self.weight < 0 {
self.weight = 0
}
}
}
class CreateWorkoutSuperSet: ObservableObject, Identifiable, Equatable {
static func == (lhs: CreateWorkoutSuperSet, rhs: CreateWorkoutSuperSet) -> Bool {
lhs.id == rhs.id
}
let id = UUID()
@Published var exercises = [CreateWorkoutExercise]()
@Published var numberOfRounds = 0
func increaseNumberOfRounds() {
self.numberOfRounds += 1
}
func decreaseNumberOfRounds() {
self.numberOfRounds -= 1
if self.numberOfRounds < 0 {
self.numberOfRounds = 0
}
}
func deleteExerciseForChosenSuperset(exercise: CreateWorkoutExercise) {
if let idx = exercises.firstIndex(where: {
$0.id == exercise.id
}) {
exercises.remove(at: idx)
}
}
}
class WorkoutViewModel: ObservableObject {
@Published var superSets = [CreateWorkoutSuperSet]()
@Published var title = String()
@Published var description = String()
@Published var randomValueForUpdatingValue = 0
func increaseRandomNumberForUpdating() {
randomValueForUpdatingValue += 1
}
func addNewSuperset() {
increaseRandomNumberForUpdating()
superSets.append(CreateWorkoutSuperSet())
}
func delete(superset: CreateWorkoutSuperSet) {
if let idx = superSets.firstIndex(where: {
$0.id == superset.id
}) {
superSets.remove(at: idx)
increaseRandomNumberForUpdating()
}
}
func showRoundsError() {
}
func showNoDurationOrReps() {
}
func uploadWorkout() {
var supersets = [[String: Any]]()
var supersetOrder = 1
superSets.forEach({ superset in
if superset.numberOfRounds == 0 {
showRoundsError()
return
}
var supersetInfo = [String: Any]()
supersetInfo["name"] = ""
supersetInfo["rounds"] = superset.numberOfRounds
supersetInfo["order"] = supersetOrder
var exercises = [[String: Any]]()
var exerciseOrder = 1
for exercise in superset.exercises {
if exercise.reps == 0 && exercise.duration == 0 {
showNoDurationOrReps()
return
}
let item = ["id": exercise.exercise.id,
"reps": exercise.reps,
"weight": exercise.weight,
"duration": exercise.duration,
"order": exerciseOrder] as [String : Any]
exercises.append(item)
exerciseOrder += 1
}
supersetInfo["exercises"] = exercises
supersets.append(supersetInfo)
supersetOrder += 1
})
let uploadBody = ["name": title,
"description": description,
"supersets": supersets] as [String : Any]
CreateWorkoutFetchable(postData: uploadBody).fetch(completion: { result in
DispatchQueue.main.async {
switch result {
case .success(_):
self.superSets.removeAll()
self.title = ""
NotificationCenter.default.post(name: NSNotification.Name("CreatedNewWorkout"), object: nil, userInfo: nil)
case .failure(let failure):
print(failure)
}
}
})
}
}

113
iphone/Werkout_ios/Views/CreateWorkout/CreateWorkoutItemPickerView.swift Normal file
View File

@@ -0,0 +1,113 @@
//
// CreateWorkoutItemPicker.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/25/23.
//
import SwiftUI
import Combine
struct CreateWorkoutItemPickerModel {
let id: Int
let name: String
}
class CreateWorkoutItemPickerViewModel: Identifiable, ObservableObject {
let allValues: [CreateWorkoutItemPickerModel]
@Published var selectedIds: [Int]
init(allValues: [CreateWorkoutItemPickerModel], selectedIds: [Int]) {
self.allValues = allValues
self.selectedIds = selectedIds
}
func toggleAll() {
if selectedIds.isEmpty {
selectedIds.append(contentsOf: allValues.map({ $0.id }))
} else {
selectedIds.removeAll()
}
}
}
struct CreateWorkoutItemPickerView: View {
@ObservedObject var viewModel: CreateWorkoutItemPickerViewModel
var completed: (([Int]) -> Void)
@Environment(\.dismiss) var dismiss
@State var searchString: String = ""
var body: some View {
VStack {
List() {
ForEach(viewModel.allValues, id:\.self.id) { value in
if searchString.isEmpty || value.name.lowercased().contains(searchString.lowercased()) {
HStack {
Circle()
.stroke(.blue, lineWidth: 1)
.background(Circle().fill(viewModel.selectedIds.contains(value.id) ? .blue :.clear))
.frame(width: 33, height: 33)
Text(value.name)
}
.contentShape(Rectangle())
.onTapGesture {
if viewModel.selectedIds.contains(value.id) {
if let idx = viewModel.selectedIds.firstIndex(of: value.id){
viewModel.selectedIds.remove(at: idx)
}
} else {
viewModel.selectedIds.append(value.id)
}
}
}
}
}
TextField("Filter", text: $searchString)
.padding()
HStack {
Button(action: {
viewModel.toggleAll()
}, label: {
Image(systemName: "checklist")
.font(.title)
})
.frame(maxWidth: 44, alignment: .center)
.frame(height: 44)
.foregroundColor(.green)
.background(.white)
.cornerRadius(8)
.padding()
Button(action: {
completed(viewModel.selectedIds)
dismiss()
}, label: {
Text("done")
})
.frame(maxWidth: .infinity, alignment: .center)
.frame(height: 44)
.foregroundColor(.blue)
.background(.yellow)
.cornerRadius(8)
.padding()
.frame(maxWidth: .infinity)
}
}
}
}
struct CreateWorkoutItemPickerView_Previews: PreviewProvider {
static let fakeValues = [CreateWorkoutItemPickerModel(id: 1, name: "one"),
CreateWorkoutItemPickerModel(id: 2, name: "two"),
CreateWorkoutItemPickerModel(id: 3, name: "three")]
static var previews: some View {
CreateWorkoutItemPickerView(viewModel: CreateWorkoutItemPickerViewModel(allValues: fakeValues, selectedIds: [1]), completed: { selectedIds in
})
}
}

164
iphone/Werkout_ios/Views/CreateWorkout/CreateWorkoutMainView.swift Normal file
View File

@@ -0,0 +1,164 @@
//
// CreateWorkoutView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/15/23.
//
import SwiftUI
struct CreateWorkoutMainView: View {
@ObservedObject var viewModel = WorkoutViewModel()
@State private var showAddExercise = false
@State var selectedCreateWorkoutSuperSet: CreateWorkoutSuperSet?
var body: some View {
VStack {
TextField("Title", text: $viewModel.title)
.padding()
.frame(height: 55)
.textFieldStyle(OvalTextFieldStyle())
TextField("Description", text: $viewModel.description)
.padding()
.frame(height: 55)
.textFieldStyle(OvalTextFieldStyle())
ScrollViewReader { proxy in
List() {
ForEach($viewModel.superSets, id: \.id) { superset in
Section {
ForEach(superset.exercises, id: \.id) { exercise in
HStack {
VStack {
Text(exercise.wrappedValue.exercise.name)
.font(.title2)
.frame(maxWidth: .infinity)
if exercise.wrappedValue.exercise.side != nil && exercise.wrappedValue.exercise.side!.count > 0 {
Text(exercise.wrappedValue.exercise.side!)
.font(.title3)
.frame(maxWidth: .infinity, alignment: .center)
}
CreateExerciseActionsView(workoutExercise: exercise.wrappedValue,
superset: superset.wrappedValue,
viewModel: viewModel)
}
}
}
HStack {
Stepper("Number of rounds", onIncrement: {
superset.wrappedValue.increaseNumberOfRounds()
viewModel.increaseRandomNumberForUpdating()
viewModel.objectWillChange.send()
}, onDecrement: {
superset.wrappedValue.decreaseNumberOfRounds()
viewModel.increaseRandomNumberForUpdating()
viewModel.objectWillChange.send()
})
Text("\(superset.wrappedValue.numberOfRounds)")
.foregroundColor(superset.numberOfRounds.wrappedValue > 0 ? .black : .red)
.bold()
}
CreateWorkoutSupersetActionsView(workoutSuperSet: superset.wrappedValue,
showAddExercise: $showAddExercise,
viewModel: viewModel,
selectedCreateWorkoutSuperSet: $selectedCreateWorkoutSuperSet)
}
}
Text("this is the bottom 🤷‍♂️")
.id(999)
.listRowSeparator(.hidden)
}
.onChange(of: viewModel.randomValueForUpdatingValue, perform: { newValue in
withAnimation {
proxy.scrollTo(999, anchor: .bottom)
}
})
}
// .overlay(Group {
// if($viewModel.superSets.isEmpty) {
// ZStack() {
// Color(uiColor: .secondarySystemBackground)
// }
// }
// })
Divider()
HStack {
Button("Add Superset", action: {
viewModel.addNewSuperset()
})
.frame(maxWidth: .infinity, alignment: .center)
.frame(height: 44)
.foregroundColor(.blue)
.background(.yellow)
.cornerRadius(8)
.padding()
.frame(maxWidth: .infinity)
Divider()
Button("Done", action: {
viewModel.uploadWorkout()
})
.frame(maxWidth: .infinity, alignment: .center)
.frame(height: 44)
.foregroundColor(.white)
.background(.blue)
.cornerRadius(8)
.padding()
.frame(maxWidth: .infinity)
.disabled(viewModel.title.isEmpty)
}
.frame(height: 44)
.padding(.bottom)
}
.sheet(isPresented: $showAddExercise) {
AddExerciseView(selectedExercise: { exercise in
let workoutExercise = CreateWorkoutExercise(exercise: exercise)
selectedCreateWorkoutSuperSet?.exercises.append(workoutExercise)
// if left or right auto add the other side
// with a recover in between b/c its
// eaiser to delete a recover than add one
if exercise.side != nil && exercise.side!.count > 0 {
let exercises = DataStore.shared.allExercise?.filter({
$0.name == exercise.name
})
let recover = DataStore.shared.allExercise?.first(where: {
$0.name.lowercased() == "recover"
})
if let exercises = exercises, let recover = recover {
if exercises.count == 2 {
let recoverWorkoutExercise = CreateWorkoutExercise(exercise: recover)
selectedCreateWorkoutSuperSet?.exercises.append(recoverWorkoutExercise)
for LRExercise in exercises {
if LRExercise.id != exercise.id {
let otherSideExercise = CreateWorkoutExercise(exercise: LRExercise)
selectedCreateWorkoutSuperSet?.exercises.append(otherSideExercise)
}
}
}
}
}
viewModel.increaseRandomNumberForUpdating()
viewModel.objectWillChange.send()
selectedCreateWorkoutSuperSet = nil
})
}
}
}
//struct CreateWorkoutView_Previews: PreviewProvider {
// static var previews: some View {
// CreateWorkoutView()
// }
//}

53
iphone/Werkout_ios/Views/CreateWorkout/CreateWorkoutSupersetActionsView.swift Normal file
View File

@@ -0,0 +1,53 @@
//
// CreateWorkoutSupersetActionsView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/18/23.
//
import SwiftUI
struct CreateWorkoutSupersetActionsView: View {
var workoutSuperSet: CreateWorkoutSuperSet
@Binding var showAddExercise: Bool
var viewModel: WorkoutViewModel
@Binding var selectedCreateWorkoutSuperSet: CreateWorkoutSuperSet?
var body: some View {
HStack {
Button(action: {
selectedCreateWorkoutSuperSet = workoutSuperSet
showAddExercise.toggle()
}) {
Text("Add exercise")
.padding()
}
.foregroundColor(.white)
.background(.green)
.cornerRadius(10)
.frame(maxWidth: .infinity, alignment: .center)
.buttonStyle(BorderlessButtonStyle())
Button(action: {
viewModel.delete(superset: workoutSuperSet)
viewModel.increaseRandomNumberForUpdating()
viewModel.objectWillChange.send()
}) {
Text("Delete superset")
.padding()
}
.foregroundColor(.white)
.background(.red)
.cornerRadius(10)
.frame(maxWidth: .infinity, alignment: .center)
.buttonStyle(BorderlessButtonStyle())
}
}
}
//struct CreateWorkoutSupersetActionsView_Previews: PreviewProvider {
// static var previews: some View {
// CreateWorkoutSupersetActionsView()
// }
//}

116
iphone/Werkout_ios/Views/ExternalWorkoutDetailView.swift Normal file
View File

@@ -0,0 +1,116 @@
//
// ExternalView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/13/23.
//
import SwiftUI
import AVKit
struct ExternalWorkoutDetailView: View {
@StateObject var bridgeModule = BridgeModule.shared
@State var avPlayer = AVPlayer(url: URL(string: "https://dev.werkout.fitness/media/exercise_videos/2_Dumbbell_Lateral_Lunges.mp4")!)
@State var smallAVPlayer = AVPlayer(url: URL(string: "https://dev.werkout.fitness/media/exercise_videos/2_Dumbbell_Lateral_Lunges.mp4")!)
@AppStorage(Constants.extThotStyle) private var extThotStyle: ThotStyle = .never
@AppStorage(Constants.extShowNextVideo) private var extShowNextVideo: Bool = false
@AppStorage(Constants.thotGenderOption) private var thotGenderOption: String = "female"
var body: some View {
ZStack {
if let workout = bridgeModule.currentExerciseInfo.workout {
GeometryReader { metrics in
VStack {
HStack {
if extThotStyle != .off {
PlayerView(player: $avPlayer)
.frame(width: metrics.size.width * 0.5, height: metrics.size.height * 0.8)
.onAppear{
avPlayer.play()
}
}
VStack {
ExtExerciseList(workout: workout,
allSupersetExecerciseIndex: bridgeModule.currentExerciseInfo.allSupersetExecerciseIndex)
}
.frame(width: metrics.size.width * 0.4, height: metrics.size.height * 0.8)
.padding([.top, .bottom], 20)
}
HStack {
ExtCountdownView()
.padding(.leading, 50)
.padding(.bottom, 20)
if extShowNextVideo && extThotStyle != .off {
PlayerView(player: $smallAVPlayer)
.frame(width: metrics.size.width * 0.2,
height: metrics.size.height * 0.2)
.onAppear{
avPlayer.play()
}
}
}
.background(Color(uiColor: .tertiarySystemGroupedBackground))
}
}
} else {
Image("icon")
.resizable()
.edgesIgnoringSafeArea(.all)
.scaledToFill()
}
}
.onChange(of: bridgeModule.isInWorkout, perform: { _ in
playVideos()
})
.onChange(of: bridgeModule.currentExerciseInfo.allSupersetExecerciseIndex, perform: { _ in
playVideos()
})
.frame(maxWidth: .infinity, maxHeight: .infinity)
.background(bridgeModule.currentExerciseInfo.workout == nil ? Color(red: 157/255, green: 138/255, blue: 255/255) : Color(uiColor: .systemBackground))
.onReceive(NotificationCenter.default.publisher(
for: UIScene.willEnterForegroundNotification)) { _ in
avPlayer.play()
smallAVPlayer.play()
}
}
func playVideos() {
if let currentExtercise = bridgeModule.currentExerciseInfo.currentExercise {
if let videoURL = VideoURLCreator.videoURL(
thotStyle: extThotStyle,
gender: thotGenderOption,
defaultVideoURLStr: currentExtercise.exercise.videoURL,
exerciseName: currentExtercise.exercise.name,
workout: bridgeModule.currentExerciseInfo.workout) {
avPlayer = AVPlayer(url: videoURL)
avPlayer.play()
}
if let smallVideoURL = VideoURLCreator.videoURL(
thotStyle: .never,
gender: thotGenderOption,
defaultVideoURLStr: BridgeModule.shared.currentExerciseInfo.nextExerciseInfo?.exercise.videoURL,
exerciseName: BridgeModule.shared.currentExerciseInfo.nextExerciseInfo?.exercise.name,
workout: bridgeModule.currentExerciseInfo.workout),
extShowNextVideo {
smallAVPlayer = AVPlayer(url: smallVideoURL)
smallAVPlayer.play()
}
}
}
}
//struct ExternalWorkoutDetailView_Previews: PreviewProvider {
// static var bridge = BridgeModule.shared
//
// static var previews: some View {
// ExternalWorkoutDetailView().environmentObject({ () -> BridgeModule in
// let envObj = BridgeModule.shared
// envObj.currentWorkout = nil //PreviewData.workout()
// bridge.currentExercise = PreviewData.workout().exercisesSortedByCreated_at.first!
// return envObj
// }() )
// }
//}

93
iphone/Werkout_ios/Views/Login/LoginView.swift Normal file
View File

@@ -0,0 +1,93 @@
//
// LoginView.swift
// WekoutThotViewer
//
// Created by Trey Tartt on 6/18/24.
//
import SwiftUI
struct LoginView: View {
@State var email: String = ""
@State var password: String = ""
@Environment(\.dismiss) var dismiss
let completion: (() -> Void)
@State var doingNetworkShit: Bool = false
var body: some View {
VStack {
TextField("Email", text: $email)
.textContentType(.username)
.autocapitalization(.none)
.frame(height: 55)
.textFieldStyle(PlainTextFieldStyle())
.padding([.horizontal], 4)
.overlay(RoundedRectangle(cornerRadius: 16).stroke(Color(uiColor: .clear))).background(Color(uiColor: .init(red: 255/255, green: 255/255, blue: 255/255, alpha: 1)))
.cornerRadius(8)
.padding(.top, 25)
SecureField("Password", text: $password)
.textContentType(.password)
.autocapitalization(.none)
.frame(height: 55)
.textFieldStyle(PlainTextFieldStyle())
.padding([.horizontal], 4)
.overlay(RoundedRectangle(cornerRadius: 16).stroke(Color(uiColor: .clear))).background(Color(uiColor: .init(red: 255/255, green: 255/255, blue: 255/255, alpha: 1)))
.cornerRadius(8)
if doingNetworkShit {
ProgressView("Logging In")
.padding()
.foregroundColor(.white)
.progressViewStyle(CircularProgressViewStyle(tint: .white))
.scaleEffect(1.5, anchor: .center)
} else {
Button("Login", action: {
login()
})
.frame(maxWidth: .infinity, alignment: .center)
.frame(height: 44)
.foregroundColor(.blue)
.background(.yellow)
.cornerRadius(8)
.padding()
.frame(maxWidth: .infinity)
.disabled(password.isEmpty || email.isEmpty)
}
Spacer()
}
.padding()
.background(
Image("icon")
.resizable()
.edgesIgnoringSafeArea(.all)
.scaledToFill()
)
}
func login() {
let postData = [
"email": email,
"password": password
]
doingNetworkShit = true
UserStore.shared.login(postData: postData, completion: { success in
doingNetworkShit = false
if success {
completion()
dismiss()
}
})
}
}
struct LoginView_Previews: PreviewProvider {
static var previews: some View {
LoginView(completion: {
})
}
}

31
iphone/Werkout_ios/Views/MainView.swift Normal file
View File

@@ -0,0 +1,31 @@
//
// ContentView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/13/23.
//
import SwiftUI
import CoreData
struct MainView: View {
@State var workout: Workout?
@StateObject var bridgeModule = BridgeModule.shared
var body: some View {
ZStack {
if let workout = workout {
let vm = WorkoutDetailViewModel(workout: workout, isPreview: true)
WorkoutDetailView(viewModel: vm)
} else {
Text("no workout selected")
}
}
}
}
struct ContentView_Previews: PreviewProvider {
static var previews: some View {
MainView().environment(\.managedObjectContext, PersistenceController.preview.container.viewContext)
}
}

94
iphone/Werkout_ios/Views/PlanWorkoutView.swift Normal file
View File

@@ -0,0 +1,94 @@
//
// PlanWorkoutView.swift
// Werkout_ios
//
// Created by Trey Tartt on 7/2/23.
//
import SwiftUI
struct PlanWorkoutView: View {
@State var selectedDate = Date()
let workout: Workout
@Environment(\.dismiss) var dismiss
var addedPlannedWorkout: (() -> Void)?
var body: some View {
VStack() {
Text(workout.name)
.font(.title)
Text(selectedDate.formatted(date: .abbreviated, time: .omitted))
.font(.system(size: 28))
.bold()
.foregroundColor(Color.accentColor)
.padding()
.animation(.spring(), value: selectedDate)
Divider().frame(height: 1)
DatePicker("Select Date", selection: $selectedDate, displayedComponents: [.date])
.padding(.horizontal)
.datePickerStyle(.graphical)
Divider()
HStack {
Button(action: {
planWorkout()
}, label: {
Image(systemName: "plus.app")
.font(.title)
.frame(maxWidth: .infinity, maxHeight: .infinity)
})
.frame(maxWidth: .infinity, alignment: .center)
.frame(height: 44)
.foregroundColor(.blue)
.background(.yellow)
.cornerRadius(8)
.padding()
Button(action: {
dismiss()
}, label: {
Image(systemName: "xmark.octagon.fill")
.font(.title)
.frame(maxWidth: .infinity, maxHeight: .infinity)
})
.frame(maxWidth: .infinity, alignment: .center)
.frame(height: 44)
.foregroundColor(.white)
.background(.red)
.cornerRadius(8)
.padding()
}
Spacer()
}
.padding()
}
func planWorkout() {
let postData = [
"on_date": selectedDate.formatForPlannedWorkout,
"workout": workout.id
] as [String : Any]
PlanWorkoutFetchable(postData: postData).fetch(completion: { result in
switch result {
case .success(_):
UserStore.shared.fetchPlannedWorkouts()
dismiss()
addedPlannedWorkout?()
case .failure(_):
fatalError("shit broke")
}
})
}
}
struct PlanWorkoutView_Previews: PreviewProvider {
static var previews: some View {
PlanWorkoutView(workout: PreviewData.workout())
}
}

21
iphone/Werkout_ios/Views/WorkoutDetail/CurrentWorkoutElapsedTimeView.swift Normal file
View File

@@ -0,0 +1,21 @@
//
// CurrentWorkoutElapsedTimeView.swift
// Werkout_ios
//
// Created by Trey Tartt on 7/7/23.
//
import SwiftUI
struct CurrentWorkoutElapsedTimeView: View {
@ObservedObject var bridgeModule = BridgeModule.shared
var body: some View {
if bridgeModule.currentWorkoutRunTimeInSeconds > -1 {
VStack {
Text("\(Double(bridgeModule.currentWorkoutRunTimeInSeconds).asString(style: .positional))")
.font(.title2)
}
}
}
}

160
iphone/Werkout_ios/Views/WorkoutDetail/ExerciseListView.swift Normal file
View File

@@ -0,0 +1,160 @@
//
// ExerciseListView.swift
// Werkout_ios
//
// Created by Trey Tartt on 7/7/23.
//
import SwiftUI
import AVKit
struct ExerciseListView: View {
@AppStorage(Constants.phoneThotStyle) private var phoneThotStyle: ThotStyle = .never
@ObservedObject var bridgeModule = BridgeModule.shared
@State var avPlayer = AVPlayer(url: URL(string: "https://dev.werkout.fitness/media/exercise_videos/2_Dumbbell_Lateral_Lunges.mp4")!)
var workout: Workout
@Binding var showExecersizeInfo: Bool
@AppStorage(Constants.thotGenderOption) private var thotGenderOption: String = "female"
@State var videoExercise: Exercise? {
didSet {
if let videoURL = VideoURLCreator.videoURL(
thotStyle: phoneThotStyle,
gender: thotGenderOption,
defaultVideoURLStr: self.videoExercise?.videoURL,
exerciseName: self.videoExercise?.name,
workout: bridgeModule.currentExerciseInfo.workout) {
avPlayer = AVPlayer(url: videoURL)
avPlayer.play()
}
}
}
var body: some View {
if let supersets = workout.supersets {
ScrollViewReader { proxy in
List() {
ForEach(supersets.indices, id: \.self) { supersetIndex in
let superset = supersets[supersetIndex]
Section(content: {
ForEach(superset.exercises.indices, id: \.self) { exerciseIndex in
let supersetExecercise = superset.exercises[exerciseIndex]
VStack {
HStack {
if bridgeModule.isInWorkout &&
supersetIndex == bridgeModule.currentExerciseInfo.supersetIndex &&
exerciseIndex == bridgeModule.currentExerciseInfo.exerciseIndex {
Image(systemName: "figure.run")
.foregroundColor(Color("appColor"))
}
Text(supersetExecercise.exercise.extName)
Spacer()
if let reps = supersetExecercise.reps,
reps > 0 {
HStack {
Image(systemName: "number")
.foregroundColor(.white)
.frame(width: 20, alignment: .leading)
Text("\(reps)")
.foregroundColor(.white)
.frame(width: 30, alignment: .trailing)
}
.padding([.top, .bottom], 5)
.padding([.leading], 10)
.padding([.trailing], 15)
.background(.blue)
.cornerRadius(5, corners: [.topLeft, .bottomLeft])
.frame(alignment: .trailing)
}
if let duration = supersetExecercise.duration,
duration > 0 {
HStack {
Image(systemName: "stopwatch")
.foregroundColor(.white)
.frame(width: 20, alignment: .leading)
Text("\(duration)")
.foregroundColor(.white)
.frame(width: 30, alignment: .trailing)
}
.padding([.top, .bottom], 5)
.padding([.leading], 10)
.padding([.trailing], 15)
.background(.green)
.cornerRadius(5, corners: [.topLeft, .bottomLeft])
}
}
.padding(.trailing, -20)
.contentShape(Rectangle())
.onTapGesture {
if bridgeModule.isInWorkout {
bridgeModule.goToExerciseAt(section: supersetIndex, row: exerciseIndex)
} else {
videoExercise = supersetExecercise.exercise
}
}
if bridgeModule.isInWorkout &&
supersetIndex == bridgeModule.currentExerciseInfo.supersetIndex &&
exerciseIndex == bridgeModule.currentExerciseInfo.exerciseIndex &&
showExecersizeInfo {
detailView(forExercise: supersetExecercise)
}
}.id(supersetExecercise.id)
}
}, header: {
HStack {
Text(superset.name ?? "--")
.foregroundColor(Color("appColor"))
.bold()
Spacer()
Text("\(superset.rounds) rounds")
.foregroundColor(Color("appColor"))
.bold()
if let estimatedTime = superset.estimatedTime {
Text("@ " + estimatedTime.asString(style: .abbreviated))
.foregroundColor(Color("appColor"))
.bold()
}
}
})
}
}
.onChange(of: bridgeModule.currentExerciseInfo.allSupersetExecerciseIndex, perform: { newValue in
if let newCurrentExercise = bridgeModule.currentExerciseInfo.currentExercise {
withAnimation {
proxy.scrollTo(newCurrentExercise.id, anchor: .top)
}
}
})
.sheet(item: $videoExercise) { exercise in
PlayerView(player: $avPlayer)
.onAppear{
avPlayer.play()
}
}
}
}
}
func detailView(forExercise supersetExecercise: SupersetExercise) -> some View {
VStack {
Text(supersetExecercise.exercise.description)
.frame(alignment: .leading)
Divider()
Text(supersetExecercise.exercise.muscles.map({ $0.name }).joined(separator: ", "))
.frame(alignment: .leading)
}
}
}
//struct ExerciseListView_Previews: PreviewProvider {
// static var previews: some View {
// ExerciseListView(workout: PreviewData.workout(), showExecersizeInfo: )
// }
//}

229
iphone/Werkout_ios/Views/WorkoutDetail/WorkoutDetailView.swift Normal file
View File

@@ -0,0 +1,229 @@
//
// MainView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/14/23.
//
import SwiftUI
import AVKit
struct WorkoutDetailView: View {
@StateObject var viewModel: WorkoutDetailViewModel
@State var avPlayer = AVPlayer(url: URL(string: "https://dev.werkout.fitness/media/exercise_videos/2_Dumbbell_Lateral_Lunges.mp4")!)
@StateObject var bridgeModule = BridgeModule.shared
@Environment(\.dismiss) var dismiss
@AppStorage(Constants.phoneThotStyle) private var phoneThotStyle: ThotStyle = .never
@AppStorage(Constants.thotGenderOption) private var thotGenderOption: String = "female"
enum Sheet: Identifiable {
case completedWorkout([String: Any])
var id: String { return UUID().uuidString }
}
@State var presentedSheet: Sheet?
@State var workoutToPlan: Workout?
@State var showExecersizeInfo: Bool = false
var body: some View {
ZStack {
switch viewModel.status {
case .loading:
Text("Loading")
case .showWorkout(let workout):
VStack(spacing: 0) {
if bridgeModule.isInWorkout {
HStack {
CountdownView()
}
.padding()
.frame(maxWidth: .infinity)
if phoneThotStyle != .off {
GeometryReader { metrics in
ZStack {
PlayerView(player: $avPlayer)
.frame(width: metrics.size.width * 1, height: metrics.size.height * 1)
.onAppear{
avPlayer.play()
}
Button(action: {
if let assetURL = ((avPlayer.currentItem?.asset) as? AVURLAsset)?.url,
let currentExtercise = bridgeModule.currentExerciseInfo.currentExercise,
let otherVideoURL = VideoURLCreator.videoURL(
thotStyle: VideoURLCreator.otherVideoType(forVideoURL: assetURL),
gender: thotGenderOption,
defaultVideoURLStr: currentExtercise.exercise.videoURL,
exerciseName: currentExtercise.exercise.name,
workout: bridgeModule.currentExerciseInfo.workout) {
avPlayer = AVPlayer(url: otherVideoURL)
avPlayer.play()
}
}, label: {
Image(systemName: "arrow.triangle.2.circlepath.camera.fill")
.frame(width: 44, height: 44)
.foregroundColor(Color("appColor"))
})
.foregroundColor(.blue)
.cornerRadius(4)
.frame(width: 160, height: 120)
.position(x: metrics.size.width - 22, y: metrics.size.height - 30)
Button(action: {
showExecersizeInfo.toggle()
}, label: {
Image(systemName: "info.circle.fill")
.frame(width: 44, height: 44)
.foregroundColor(Color("appColor"))
})
.foregroundColor(.blue)
.cornerRadius(4)
.frame(width: 120, height: 120)
.position(x: 22, y: metrics.size.height - 30)
}
}
.padding([.top, .bottom])
.background(Color(uiColor: .tertiarySystemBackground))
}
}
if !bridgeModule.isInWorkout {
InfoView(workout: workout)
.padding(.bottom)
}
if bridgeModule.isInWorkout {
Divider()
.background(Color(uiColor: .secondaryLabel))
HStack {
Text("\(bridgeModule.currentExerciseInfo.currentRound) of \(bridgeModule.currentExerciseInfo.numberOfRoundsInCurrentSuperSet)")
.font(.title3)
.bold()
.frame(maxWidth: .infinity, alignment: .leading)
.padding(.leading, 10)
CurrentWorkoutElapsedTimeView()
.frame(maxWidth: .infinity, alignment: .center)
Text("\(bridgeModule.currentExerciseInfo.allSupersetExecerciseIndex+1)/\(bridgeModule.currentExerciseInfo.workout?.allSupersetExecercise?.count ?? -99)")
.font(.title3)
.bold()
.frame(maxWidth: .infinity, alignment: .trailing)
.padding(.trailing, 10)
}
.padding([.top, .bottom])
.background(Color(uiColor: .tertiarySystemBackground))
}
Divider()
.background(Color(uiColor: .secondaryLabel))
ExerciseListView(workout: workout, showExecersizeInfo: $showExecersizeInfo)
.padding([.top, .bottom], 10)
.background(Color(uiColor: .systemGroupedBackground))
ActionsView(completedWorkout: {
bridgeModule.completeWorkout()
}, planWorkout: { workout in
workoutToPlan = workout
}, workout: workout, showAddToCalendar: viewModel.isPreview, startWorkoutAction: {
startWorkout(workout: workout)
})
.frame(height: 44)
}
.sheet(item: $presentedSheet) { item in
switch item {
case .completedWorkout(let data):
CompletedWorkoutView(postData: data,
workout: workout,
completedWorkoutDismissed: { uploaded in
if uploaded {
dismiss()
}
})
}
}
.sheet(item: $workoutToPlan) { workout in
PlanWorkoutView(workout: workout, addedPlannedWorkout: {
dismiss()
})
}
}
}
.onChange(of: bridgeModule.currentExerciseInfo.allSupersetExecerciseIndex, perform: { _ in
playVideos()
})
.onChange(of: bridgeModule.isInWorkout, perform: { _ in
playVideos()
})
.onAppear{
if let currentExtercise = bridgeModule.currentExerciseInfo.currentExercise {
if let videoURL = VideoURLCreator.videoURL(
thotStyle: phoneThotStyle,
gender: thotGenderOption,
defaultVideoURLStr: currentExtercise.exercise.videoURL,
exerciseName: currentExtercise.exercise.name,
workout: bridgeModule.currentExerciseInfo.workout) {
avPlayer = AVPlayer(url: videoURL)
avPlayer.play()
}
}
}
.onReceive(NotificationCenter.default.publisher(
for: UIScene.willEnterForegroundNotification)) { _ in
avPlayer.play()
}
}
func playVideos() {
if let currentExtercise = bridgeModule.currentExerciseInfo.currentExercise {
if let videoURL = VideoURLCreator.videoURL(
thotStyle: phoneThotStyle,
gender: thotGenderOption,
defaultVideoURLStr: currentExtercise.exercise.videoURL,
exerciseName: currentExtercise.exercise.name,
workout: bridgeModule.currentExerciseInfo.workout) {
avPlayer = AVPlayer(url: videoURL)
avPlayer.play()
}
}
}
func startWorkout(workout: Workout) {
bridgeModule.completedWorkout = {
if let workoutData = createWorkoutData() {
presentedSheet = .completedWorkout(workoutData)
bridgeModule.resetCurrentWorkout()
}
}
bridgeModule.start(workout: workout)
}
func createWorkoutData() -> [String:Any]? {
guard let workoutid = bridgeModule.currentExerciseInfo.workout?.id,
let startTime = bridgeModule.workoutStartDate?.timeFormatForUpload,
let endTime = bridgeModule.workoutEndDate?.timeFormatForUpload else {
return nil
}
let postBody = [
"difficulty": 1,
"workout_start_time": startTime,
"workout_end_time": endTime,
"workout": workoutid,
"total_time": bridgeModule.currentWorkoutRunTimeInSeconds
] as [String : Any]
return postBody
}
}
struct WorkoutDetailView_Previews: PreviewProvider {
static let workoutDetail = PreviewData.workout()
static var previews: some View {
WorkoutDetailView(viewModel: WorkoutDetailViewModel(workout: WorkoutDetailView_Previews.workoutDetail, status: .showWorkout(WorkoutDetailView_Previews.workoutDetail), isPreview: true))
}
}

39
iphone/Werkout_ios/Views/WorkoutDetail/WorkoutDetailViewModel.swift Normal file
View File

@@ -0,0 +1,39 @@
//
// MainViewViewModel.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/14/23.
//
import Combine
import Foundation
class WorkoutDetailViewModel: ObservableObject {
enum WorkoutDetailViewModelStatus {
case loading
case showWorkout(Workout)
}
@Published var status: WorkoutDetailViewModelStatus
let isPreview: Bool
init(workout: Workout, status: WorkoutDetailViewModelStatus? = nil, isPreview: Bool) {
self.status = .loading
self.isPreview = isPreview
if let passedStatus = status {
self.status = passedStatus
} else {
WorkoutDetailFetchable(workoutID: workout.id).fetch(completion: { result in
switch result {
case .success(let model):
DispatchQueue.main.async {
self.status = .showWorkout(model)
}
case .failure(let failure):
fatalError("failed \(failure.localizedDescription)")
}
})
}
}
}

93
iphone/Werkout_ios/Views/WorkoutHistoryView.swift Normal file
View File

@@ -0,0 +1,93 @@
//
// WorkoutHistoryView.swift
// Werkout_ios
//
// Created by Trey Tartt on 6/26/23.
//
import SwiftUI
struct WorkoutHistoryView: View {
enum DifficltyString: Int {
case easy = 1
case moderate
case average
case hard
case death
var stringValue: String {
switch self {
case .easy:
return "Easy"
case .moderate:
return "Moderate"
case .average:
return "Average"
case .hard:
return "Hard"
case .death:
return "Death"
}
}
}
let completedWorkouts: [CompletedWorkout]
@State private var selectedPlannedWorkout: Workout?
var body: some View {
List {
ForEach(completedWorkouts, id:\.self.id) { completedWorkout in
HStack {
VStack {
if let date = completedWorkout.workoutStartTime.dateFromServerDate {
Text(DateFormatter().shortMonthSymbols[date.get(.month) - 1])
Text("\(date.get(.day))")
Text("\(date.get(.hour))")
}
}
VStack(alignment: .leading) {
Text(completedWorkout.workout.name)
.font(.title3)
if let desc = completedWorkout.workout.description {
Text(desc)
.font(.footnote)
}
Divider()
if let difficulty = completedWorkout.difficulty,
let string = DifficltyString.init(rawValue: difficulty)?.stringValue {
Text(string)
}
if let notes = completedWorkout.notes {
Text(notes)
}
}
.padding(.leading)
.contentShape(Rectangle())
.onTapGesture {
selectedPlannedWorkout = completedWorkout.workout
}
}
}
}
.sheet(item: $selectedPlannedWorkout) { item in
let viewModel = WorkoutDetailViewModel(workout: item, isPreview: true)
WorkoutDetailView(viewModel: viewModel)
}
}
}
struct WorkoutHistoryView_Previews: PreviewProvider {
static let fakeHistory = PreviewData.parseCompletedWorkouts()
static var previews: some View {
WorkoutHistoryView(completedWorkouts: fakeHistory)
}
}