diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,367 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,28 @@ +# gogol-fitness + +* [Version](#version) +* [Description](#description) +* [Contribute](#contribute) +* [Licence](#licence) + + +## Version + +`0.0.1` + + +## Description + +A client library for the Google Fitness. + + +## Contribute + +For any problems, comments, or feedback please create an issue [here on GitHub](https://github.com/brendanhay/amazonka/issues). + +> _Note:_ this library is an auto-generated Haskell package. Please see `amazonka-gen` for more information. + + +## Licence + +`gogol-fitness` is released under the [Mozilla Public License Version 2.0](http://www.mozilla.org/MPL/). diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/gen/Network/Google/Fitness.hs b/gen/Network/Google/Fitness.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Fitness.hs @@ -0,0 +1,271 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} + +-- | +-- Module : Network.Google.Fitness +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Google Fit API +-- +-- /See:/ +module Network.Google.Fitness + ( + -- * Service Configuration + fitnessService + + -- * API Declaration + , FitnessAPI + + -- * Resources + + -- ** fitness.users.dataSources.create + , module Network.Google.Resource.Fitness.Users.DataSources.Create + + -- ** fitness.users.dataSources.datasets.delete + , module Network.Google.Resource.Fitness.Users.DataSources.DataSets.Delete + + -- ** fitness.users.dataSources.datasets.get + , module Network.Google.Resource.Fitness.Users.DataSources.DataSets.Get + + -- ** fitness.users.dataSources.datasets.patch + , module Network.Google.Resource.Fitness.Users.DataSources.DataSets.Patch + + -- ** fitness.users.dataSources.delete + , module Network.Google.Resource.Fitness.Users.DataSources.Delete + + -- ** fitness.users.dataSources.get + , module Network.Google.Resource.Fitness.Users.DataSources.Get + + -- ** fitness.users.dataSources.list + , module Network.Google.Resource.Fitness.Users.DataSources.List + + -- ** fitness.users.dataSources.patch + , module Network.Google.Resource.Fitness.Users.DataSources.Patch + + -- ** fitness.users.dataSources.update + , module Network.Google.Resource.Fitness.Users.DataSources.Update + + -- ** fitness.users.dataset.aggregate + , module Network.Google.Resource.Fitness.Users.DataSet.Aggregate + + -- ** fitness.users.sessions.delete + , module Network.Google.Resource.Fitness.Users.Sessions.Delete + + -- ** fitness.users.sessions.list + , module Network.Google.Resource.Fitness.Users.Sessions.List + + -- ** fitness.users.sessions.update + , module Network.Google.Resource.Fitness.Users.Sessions.Update + + -- * Types + + -- ** AggregateBucketType + , AggregateBucketType (..) + + -- ** DataSet + , DataSet + , dataSet + , dsNextPageToken + , dsDataSourceId + , dsPoint + , dsMinStartTimeNs + , dsMaxEndTimeNs + + -- ** Application + , Application + , application + , aPackageName + , aName + , aVersion + , aDetailsURL + + -- ** AggregateResponse + , AggregateResponse + , aggregateResponse + , arBucket + + -- ** AggregateBy + , AggregateBy + , aggregateBy + , abDataTypeName + , abDataSourceId + + -- ** DataSourceType + , DataSourceType (..) + + -- ** BucketByActivity + , BucketByActivity + , bucketByActivity + , bbaMinDurationMillis + , bbaActivityDataSourceId + + -- ** AggregateRequest + , AggregateRequest + , aggregateRequest + , arEndTimeMillis + , arAggregateBy + , arBucketBySession + , arBucketByActivityType + , arBucketByTime + , arStartTimeMillis + , arBucketByActivitySegment + + -- ** Device + , Device + , device + , dManufacturer + , dUid + , dModel + , dVersion + , dType + + -- ** Value + , Value + , value + , vMapVal + , vFpVal + , vIntVal + , vStringVal + + -- ** BucketBySession + , BucketBySession + , bucketBySession + , bbsMinDurationMillis + + -- ** DataPoint + , DataPoint + , dataPoint + , dpOriginDataSourceId + , dpRawTimestampNanos + , dpDataTypeName + , dpValue + , dpComputationTimeMillis + , dpEndTimeNanos + , dpModifiedTimeMillis + , dpStartTimeNanos + + -- ** ListSessionsResponse + , ListSessionsResponse + , listSessionsResponse + , lsrNextPageToken + , lsrDeletedSession + , lsrSession + + -- ** AggregateBucket + , AggregateBucket + , aggregateBucket + , abEndTimeMillis + , abDataSet + , abActivity + , abType + , abStartTimeMillis + , abSession + + -- ** MapValue + , MapValue + , mapValue + , mvFpVal + + -- ** ListDataSourcesResponse + , ListDataSourcesResponse + , listDataSourcesResponse + , ldsrDataSource + + -- ** DataTypeField + , DataTypeField + , dataTypeField + , dtfFormat + , dtfName + , dtfOptional + + -- ** DataSource + , DataSource + , dataSource + , dsApplication + , dsDevice + , dsName + , dsDataType + , dsType + , dsDataStreamName + , dsDataStreamId + + -- ** DeviceType + , DeviceType (..) + + -- ** ValueMapValEntry + , ValueMapValEntry + , valueMapValEntry + , vmveValue + , vmveKey + + -- ** BucketByTime + , BucketByTime + , bucketByTime + , bbtDurationMillis + + -- ** DataType + , DataType + , dataType + , dtField + , dtName + + -- ** Session + , Session + , session + , sEndTimeMillis + , sActiveTimeMillis + , sApplication + , sActivityType + , sName + , sModifiedTimeMillis + , sId + , sStartTimeMillis + , sDescription + + -- ** DataTypeFieldFormat + , DataTypeFieldFormat (..) + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude +import Network.Google.Resource.Fitness.Users.DataSet.Aggregate +import Network.Google.Resource.Fitness.Users.DataSources.Create +import Network.Google.Resource.Fitness.Users.DataSources.DataSets.Delete +import Network.Google.Resource.Fitness.Users.DataSources.DataSets.Get +import Network.Google.Resource.Fitness.Users.DataSources.DataSets.Patch +import Network.Google.Resource.Fitness.Users.DataSources.Delete +import Network.Google.Resource.Fitness.Users.DataSources.Get +import Network.Google.Resource.Fitness.Users.DataSources.List +import Network.Google.Resource.Fitness.Users.DataSources.Patch +import Network.Google.Resource.Fitness.Users.DataSources.Update +import Network.Google.Resource.Fitness.Users.Sessions.Delete +import Network.Google.Resource.Fitness.Users.Sessions.List +import Network.Google.Resource.Fitness.Users.Sessions.Update + +{- $resources +TODO +-} + +-- | Represents the entirety of the methods and resources available for the Fitness service. +type FitnessAPI = + UsersDataSetAggregateResource :<|> + UsersDataSourcesDataSetsPatchResource + :<|> UsersDataSourcesDataSetsGetResource + :<|> UsersDataSourcesDataSetsDeleteResource + :<|> UsersDataSourcesListResource + :<|> UsersDataSourcesPatchResource + :<|> UsersDataSourcesGetResource + :<|> UsersDataSourcesCreateResource + :<|> UsersDataSourcesDeleteResource + :<|> UsersDataSourcesUpdateResource + :<|> UsersSessionsListResource + :<|> UsersSessionsDeleteResource + :<|> UsersSessionsUpdateResource diff --git a/gen/Network/Google/Fitness/Types.hs b/gen/Network/Google/Fitness/Types.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Fitness/Types.hs @@ -0,0 +1,228 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Fitness.Types +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.Google.Fitness.Types + ( + -- * Service Configuration + fitnessService + + -- * OAuth Scopes + , fitnessBodyReadScope + , fitnessActivityReadScope + , fitnessActivityWriteScope + , fitnessLocationReadScope + , fitnessLocationWriteScope + , fitnessBodyWriteScope + + -- * AggregateBucketType + , AggregateBucketType (..) + + -- * DataSet + , DataSet + , dataSet + , dsNextPageToken + , dsDataSourceId + , dsPoint + , dsMinStartTimeNs + , dsMaxEndTimeNs + + -- * Application + , Application + , application + , aPackageName + , aName + , aVersion + , aDetailsURL + + -- * AggregateResponse + , AggregateResponse + , aggregateResponse + , arBucket + + -- * AggregateBy + , AggregateBy + , aggregateBy + , abDataTypeName + , abDataSourceId + + -- * DataSourceType + , DataSourceType (..) + + -- * BucketByActivity + , BucketByActivity + , bucketByActivity + , bbaMinDurationMillis + , bbaActivityDataSourceId + + -- * AggregateRequest + , AggregateRequest + , aggregateRequest + , arEndTimeMillis + , arAggregateBy + , arBucketBySession + , arBucketByActivityType + , arBucketByTime + , arStartTimeMillis + , arBucketByActivitySegment + + -- * Device + , Device + , device + , dManufacturer + , dUid + , dModel + , dVersion + , dType + + -- * Value + , Value + , value + , vMapVal + , vFpVal + , vIntVal + , vStringVal + + -- * BucketBySession + , BucketBySession + , bucketBySession + , bbsMinDurationMillis + + -- * DataPoint + , DataPoint + , dataPoint + , dpOriginDataSourceId + , dpRawTimestampNanos + , dpDataTypeName + , dpValue + , dpComputationTimeMillis + , dpEndTimeNanos + , dpModifiedTimeMillis + , dpStartTimeNanos + + -- * ListSessionsResponse + , ListSessionsResponse + , listSessionsResponse + , lsrNextPageToken + , lsrDeletedSession + , lsrSession + + -- * AggregateBucket + , AggregateBucket + , aggregateBucket + , abEndTimeMillis + , abDataSet + , abActivity + , abType + , abStartTimeMillis + , abSession + + -- * MapValue + , MapValue + , mapValue + , mvFpVal + + -- * ListDataSourcesResponse + , ListDataSourcesResponse + , listDataSourcesResponse + , ldsrDataSource + + -- * DataTypeField + , DataTypeField + , dataTypeField + , dtfFormat + , dtfName + , dtfOptional + + -- * DataSource + , DataSource + , dataSource + , dsApplication + , dsDevice + , dsName + , dsDataType + , dsType + , dsDataStreamName + , dsDataStreamId + + -- * DeviceType + , DeviceType (..) + + -- * ValueMapValEntry + , ValueMapValEntry + , valueMapValEntry + , vmveValue + , vmveKey + + -- * BucketByTime + , BucketByTime + , bucketByTime + , bbtDurationMillis + + -- * DataType + , DataType + , dataType + , dtField + , dtName + + -- * Session + , Session + , session + , sEndTimeMillis + , sActiveTimeMillis + , sApplication + , sActivityType + , sName + , sModifiedTimeMillis + , sId + , sStartTimeMillis + , sDescription + + -- * DataTypeFieldFormat + , DataTypeFieldFormat (..) + ) where + +import Network.Google.Fitness.Types.Product +import Network.Google.Fitness.Types.Sum +import Network.Google.Prelude + +-- | Default request referring to version 'v1' of the Fitness. This contains the host and root path used as a starting point for constructing service requests. +fitnessService :: Service +fitnessService + = defaultService (ServiceId "fitness:v1") + "www.googleapis.com" + +-- | View body sensor information in Google Fit +fitnessBodyReadScope :: OAuthScope +fitnessBodyReadScope = "https://www.googleapis.com/auth/fitness.body.read"; + +-- | View your activity information in Google Fit +fitnessActivityReadScope :: OAuthScope +fitnessActivityReadScope = "https://www.googleapis.com/auth/fitness.activity.read"; + +-- | View and store your activity information in Google Fit +fitnessActivityWriteScope :: OAuthScope +fitnessActivityWriteScope = "https://www.googleapis.com/auth/fitness.activity.write"; + +-- | View your stored location data in Google Fit +fitnessLocationReadScope :: OAuthScope +fitnessLocationReadScope = "https://www.googleapis.com/auth/fitness.location.read"; + +-- | View and store your location data in Google Fit +fitnessLocationWriteScope :: OAuthScope +fitnessLocationWriteScope = "https://www.googleapis.com/auth/fitness.location.write"; + +-- | View and store body sensor data in Google Fit +fitnessBodyWriteScope :: OAuthScope +fitnessBodyWriteScope = "https://www.googleapis.com/auth/fitness.body.write"; diff --git a/gen/Network/Google/Fitness/Types/Product.hs b/gen/Network/Google/Fitness/Types/Product.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Fitness/Types/Product.hs @@ -0,0 +1,1541 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} + +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Fitness.Types.Product +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.Google.Fitness.Types.Product where + +import Network.Google.Fitness.Types.Sum +import Network.Google.Prelude + +-- | A dataset represents a projection container for data points. They do not +-- carry any info of their own. Datasets represent a set of data points +-- from a particular data source. A data point can be found in more than +-- one dataset. +-- +-- /See:/ 'dataSet' smart constructor. +data DataSet = DataSet + { _dsNextPageToken :: !(Maybe Text) + , _dsDataSourceId :: !(Maybe Text) + , _dsPoint :: !(Maybe [DataPoint]) + , _dsMinStartTimeNs :: !(Maybe (Textual Int64)) + , _dsMaxEndTimeNs :: !(Maybe (Textual Int64)) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DataSet' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'dsNextPageToken' +-- +-- * 'dsDataSourceId' +-- +-- * 'dsPoint' +-- +-- * 'dsMinStartTimeNs' +-- +-- * 'dsMaxEndTimeNs' +dataSet + :: DataSet +dataSet = + DataSet + { _dsNextPageToken = Nothing + , _dsDataSourceId = Nothing + , _dsPoint = Nothing + , _dsMinStartTimeNs = Nothing + , _dsMaxEndTimeNs = Nothing + } + +-- | This token will be set when a dataset is received in response to a GET +-- request and the dataset is too large to be included in a single +-- response. Provide this value in a subsequent GET request to return the +-- next page of data points within this dataset. +dsNextPageToken :: Lens' DataSet (Maybe Text) +dsNextPageToken + = lens _dsNextPageToken + (\ s a -> s{_dsNextPageToken = a}) + +-- | The data stream ID of the data source that created the points in this +-- dataset. +dsDataSourceId :: Lens' DataSet (Maybe Text) +dsDataSourceId + = lens _dsDataSourceId + (\ s a -> s{_dsDataSourceId = a}) + +-- | A partial list of data points contained in the dataset, ordered by +-- largest endTimeNanos first. This list is considered complete when +-- retrieving a small dataset and partial when patching a dataset or +-- retrieving a dataset that is too large to include in a single response. +dsPoint :: Lens' DataSet [DataPoint] +dsPoint + = lens _dsPoint (\ s a -> s{_dsPoint = a}) . _Default + . _Coerce + +-- | The smallest start time of all data points in this possibly partial +-- representation of the dataset. Time is in nanoseconds from epoch. This +-- should also match the first part of the dataset identifier. +dsMinStartTimeNs :: Lens' DataSet (Maybe Int64) +dsMinStartTimeNs + = lens _dsMinStartTimeNs + (\ s a -> s{_dsMinStartTimeNs = a}) + . mapping _Coerce + +-- | The largest end time of all data points in this possibly partial +-- representation of the dataset. Time is in nanoseconds from epoch. This +-- should also match the first part of the dataset identifier. +dsMaxEndTimeNs :: Lens' DataSet (Maybe Int64) +dsMaxEndTimeNs + = lens _dsMaxEndTimeNs + (\ s a -> s{_dsMaxEndTimeNs = a}) + . mapping _Coerce + +instance FromJSON DataSet where + parseJSON + = withObject "DataSet" + (\ o -> + DataSet <$> + (o .:? "nextPageToken") <*> (o .:? "dataSourceId") + <*> (o .:? "point" .!= mempty) + <*> (o .:? "minStartTimeNs") + <*> (o .:? "maxEndTimeNs")) + +instance ToJSON DataSet where + toJSON DataSet{..} + = object + (catMaybes + [("nextPageToken" .=) <$> _dsNextPageToken, + ("dataSourceId" .=) <$> _dsDataSourceId, + ("point" .=) <$> _dsPoint, + ("minStartTimeNs" .=) <$> _dsMinStartTimeNs, + ("maxEndTimeNs" .=) <$> _dsMaxEndTimeNs]) + +-- | See: +-- google3\/java\/com\/google\/android\/apps\/heart\/platform\/api\/Application.java +-- +-- /See:/ 'application' smart constructor. +data Application = Application + { _aPackageName :: !(Maybe Text) + , _aName :: !(Maybe Text) + , _aVersion :: !(Maybe Text) + , _aDetailsURL :: !(Maybe Text) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'Application' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'aPackageName' +-- +-- * 'aName' +-- +-- * 'aVersion' +-- +-- * 'aDetailsURL' +application + :: Application +application = + Application + { _aPackageName = Nothing + , _aName = Nothing + , _aVersion = Nothing + , _aDetailsURL = Nothing + } + +-- | Package name for this application. This is used as a unique identifier +-- when created by Android applications, but cannot be specified by REST +-- clients. REST clients will have their developer project number reflected +-- into the Data Source data stream IDs, instead of the packageName. +aPackageName :: Lens' Application (Maybe Text) +aPackageName + = lens _aPackageName (\ s a -> s{_aPackageName = a}) + +-- | The name of this application. This is required for REST clients, but we +-- do not enforce uniqueness of this name. It is provided as a matter of +-- convenience for other developers who would like to identify which REST +-- created an Application or Data Source. +aName :: Lens' Application (Maybe Text) +aName = lens _aName (\ s a -> s{_aName = a}) + +-- | Version of the application. You should update this field whenever the +-- application changes in a way that affects the computation of the data. +aVersion :: Lens' Application (Maybe Text) +aVersion = lens _aVersion (\ s a -> s{_aVersion = a}) + +-- | An optional URI that can be used to link back to the application. +aDetailsURL :: Lens' Application (Maybe Text) +aDetailsURL + = lens _aDetailsURL (\ s a -> s{_aDetailsURL = a}) + +instance FromJSON Application where + parseJSON + = withObject "Application" + (\ o -> + Application <$> + (o .:? "packageName") <*> (o .:? "name") <*> + (o .:? "version") + <*> (o .:? "detailsUrl")) + +instance ToJSON Application where + toJSON Application{..} + = object + (catMaybes + [("packageName" .=) <$> _aPackageName, + ("name" .=) <$> _aName, ("version" .=) <$> _aVersion, + ("detailsUrl" .=) <$> _aDetailsURL]) + +-- +-- /See:/ 'aggregateResponse' smart constructor. +newtype AggregateResponse = AggregateResponse + { _arBucket :: Maybe [AggregateBucket] + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'AggregateResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'arBucket' +aggregateResponse + :: AggregateResponse +aggregateResponse = + AggregateResponse + { _arBucket = Nothing + } + +-- | A list of buckets containing the aggregated data. +arBucket :: Lens' AggregateResponse [AggregateBucket] +arBucket + = lens _arBucket (\ s a -> s{_arBucket = a}) . + _Default + . _Coerce + +instance FromJSON AggregateResponse where + parseJSON + = withObject "AggregateResponse" + (\ o -> + AggregateResponse <$> (o .:? "bucket" .!= mempty)) + +instance ToJSON AggregateResponse where + toJSON AggregateResponse{..} + = object (catMaybes [("bucket" .=) <$> _arBucket]) + +-- | The specification of which data to aggregate. +-- +-- /See:/ 'aggregateBy' smart constructor. +data AggregateBy = AggregateBy + { _abDataTypeName :: !(Maybe Text) + , _abDataSourceId :: !(Maybe Text) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'AggregateBy' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'abDataTypeName' +-- +-- * 'abDataSourceId' +aggregateBy + :: AggregateBy +aggregateBy = + AggregateBy + { _abDataTypeName = Nothing + , _abDataSourceId = Nothing + } + +-- | The data type to aggregate. All data sources providing this data type +-- will contribute data to the aggregation. The response will contain a +-- single dataset for this data type name. The dataset will have a data +-- source ID of derived:com.google.:com.google.android.gms:aggregated +abDataTypeName :: Lens' AggregateBy (Maybe Text) +abDataTypeName + = lens _abDataTypeName + (\ s a -> s{_abDataTypeName = a}) + +-- | A data source ID to aggregate. Mutually exclusive of dataTypeName. Only +-- data from the specified data source ID will be included in the +-- aggregation. The dataset in the response will have the same data source +-- ID. +abDataSourceId :: Lens' AggregateBy (Maybe Text) +abDataSourceId + = lens _abDataSourceId + (\ s a -> s{_abDataSourceId = a}) + +instance FromJSON AggregateBy where + parseJSON + = withObject "AggregateBy" + (\ o -> + AggregateBy <$> + (o .:? "dataTypeName") <*> (o .:? "dataSourceId")) + +instance ToJSON AggregateBy where + toJSON AggregateBy{..} + = object + (catMaybes + [("dataTypeName" .=) <$> _abDataTypeName, + ("dataSourceId" .=) <$> _abDataSourceId]) + +-- +-- /See:/ 'bucketByActivity' smart constructor. +data BucketByActivity = BucketByActivity + { _bbaMinDurationMillis :: !(Maybe (Textual Int64)) + , _bbaActivityDataSourceId :: !(Maybe Text) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'BucketByActivity' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'bbaMinDurationMillis' +-- +-- * 'bbaActivityDataSourceId' +bucketByActivity + :: BucketByActivity +bucketByActivity = + BucketByActivity + { _bbaMinDurationMillis = Nothing + , _bbaActivityDataSourceId = Nothing + } + +-- | Specifies that only activity segments of duration longer than +-- minDurationMillis are considered and used as a container for aggregated +-- data. +bbaMinDurationMillis :: Lens' BucketByActivity (Maybe Int64) +bbaMinDurationMillis + = lens _bbaMinDurationMillis + (\ s a -> s{_bbaMinDurationMillis = a}) + . mapping _Coerce + +-- | The default activity stream will be used if a specific +-- activityDataSourceId is not specified. +bbaActivityDataSourceId :: Lens' BucketByActivity (Maybe Text) +bbaActivityDataSourceId + = lens _bbaActivityDataSourceId + (\ s a -> s{_bbaActivityDataSourceId = a}) + +instance FromJSON BucketByActivity where + parseJSON + = withObject "BucketByActivity" + (\ o -> + BucketByActivity <$> + (o .:? "minDurationMillis") <*> + (o .:? "activityDataSourceId")) + +instance ToJSON BucketByActivity where + toJSON BucketByActivity{..} + = object + (catMaybes + [("minDurationMillis" .=) <$> _bbaMinDurationMillis, + ("activityDataSourceId" .=) <$> + _bbaActivityDataSourceId]) + +-- +-- /See:/ 'aggregateRequest' smart constructor. +data AggregateRequest = AggregateRequest + { _arEndTimeMillis :: !(Maybe (Textual Int64)) + , _arAggregateBy :: !(Maybe [AggregateBy]) + , _arBucketBySession :: !(Maybe BucketBySession) + , _arBucketByActivityType :: !(Maybe BucketByActivity) + , _arBucketByTime :: !(Maybe BucketByTime) + , _arStartTimeMillis :: !(Maybe (Textual Int64)) + , _arBucketByActivitySegment :: !(Maybe BucketByActivity) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'AggregateRequest' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'arEndTimeMillis' +-- +-- * 'arAggregateBy' +-- +-- * 'arBucketBySession' +-- +-- * 'arBucketByActivityType' +-- +-- * 'arBucketByTime' +-- +-- * 'arStartTimeMillis' +-- +-- * 'arBucketByActivitySegment' +aggregateRequest + :: AggregateRequest +aggregateRequest = + AggregateRequest + { _arEndTimeMillis = Nothing + , _arAggregateBy = Nothing + , _arBucketBySession = Nothing + , _arBucketByActivityType = Nothing + , _arBucketByTime = Nothing + , _arStartTimeMillis = Nothing + , _arBucketByActivitySegment = Nothing + } + +-- | The end of a window of time. Data that intersects with this time window +-- will be aggregated. The time is in milliseconds since epoch, inclusive. +arEndTimeMillis :: Lens' AggregateRequest (Maybe Int64) +arEndTimeMillis + = lens _arEndTimeMillis + (\ s a -> s{_arEndTimeMillis = a}) + . mapping _Coerce + +-- | The specification of data to be aggregated. At least one aggregateBy +-- spec must be provided. All data that is specified will be aggregated +-- using the same bucketing criteria. There will be one dataset in the +-- response for every aggregateBy spec. +arAggregateBy :: Lens' AggregateRequest [AggregateBy] +arAggregateBy + = lens _arAggregateBy + (\ s a -> s{_arAggregateBy = a}) + . _Default + . _Coerce + +-- | Specifies that data be aggregated by user sessions. Data that does not +-- fall within the time range of a session will not be included in the +-- response. Mutually exclusive of other bucketing specifications. +arBucketBySession :: Lens' AggregateRequest (Maybe BucketBySession) +arBucketBySession + = lens _arBucketBySession + (\ s a -> s{_arBucketBySession = a}) + +-- | Specifies that data be aggregated by the type of activity being +-- performed when the data was recorded. All data that was recorded during +-- a certain activity type (for the given time range) will be aggregated +-- into the same bucket. Data that was recorded while the user was not +-- active will not be included in the response. Mutually exclusive of other +-- bucketing specifications. +arBucketByActivityType :: Lens' AggregateRequest (Maybe BucketByActivity) +arBucketByActivityType + = lens _arBucketByActivityType + (\ s a -> s{_arBucketByActivityType = a}) + +-- | Specifies that data be aggregated by a single time interval. Mutually +-- exclusive of other bucketing specifications. +arBucketByTime :: Lens' AggregateRequest (Maybe BucketByTime) +arBucketByTime + = lens _arBucketByTime + (\ s a -> s{_arBucketByTime = a}) + +-- | The start of a window of time. Data that intersects with this time +-- window will be aggregated. The time is in milliseconds since epoch, +-- inclusive. +arStartTimeMillis :: Lens' AggregateRequest (Maybe Int64) +arStartTimeMillis + = lens _arStartTimeMillis + (\ s a -> s{_arStartTimeMillis = a}) + . mapping _Coerce + +-- | Specifies that data be aggregated each activity segment recored for a +-- user. Similar to bucketByActivitySegment, but bucketing is done for each +-- activity segment rather than all segments of the same type. Mutually +-- exclusive of other bucketing specifications. +arBucketByActivitySegment :: Lens' AggregateRequest (Maybe BucketByActivity) +arBucketByActivitySegment + = lens _arBucketByActivitySegment + (\ s a -> s{_arBucketByActivitySegment = a}) + +instance FromJSON AggregateRequest where + parseJSON + = withObject "AggregateRequest" + (\ o -> + AggregateRequest <$> + (o .:? "endTimeMillis") <*> + (o .:? "aggregateBy" .!= mempty) + <*> (o .:? "bucketBySession") + <*> (o .:? "bucketByActivityType") + <*> (o .:? "bucketByTime") + <*> (o .:? "startTimeMillis") + <*> (o .:? "bucketByActivitySegment")) + +instance ToJSON AggregateRequest where + toJSON AggregateRequest{..} + = object + (catMaybes + [("endTimeMillis" .=) <$> _arEndTimeMillis, + ("aggregateBy" .=) <$> _arAggregateBy, + ("bucketBySession" .=) <$> _arBucketBySession, + ("bucketByActivityType" .=) <$> + _arBucketByActivityType, + ("bucketByTime" .=) <$> _arBucketByTime, + ("startTimeMillis" .=) <$> _arStartTimeMillis, + ("bucketByActivitySegment" .=) <$> + _arBucketByActivitySegment]) + +-- | Representation of an integrated device (such as a phone or a wearable) +-- that can hold sensors. Each sensor is exposed as a data source. The main +-- purpose of the device information contained in this class is to identify +-- the hardware of a particular data source. This can be useful in +-- different ways, including: - Distinguishing two similar sensors on +-- different devices (the step counter on two nexus 5 phones, for instance) +-- - Display the source of data to the user (by using the device make \/ +-- model) - Treat data differently depending on sensor type (accelerometers +-- on a watch may give different patterns than those on a phone) - Build +-- different analysis models for each device\/version. +-- +-- /See:/ 'device' smart constructor. +data Device = Device + { _dManufacturer :: !(Maybe Text) + , _dUid :: !(Maybe Text) + , _dModel :: !(Maybe Text) + , _dVersion :: !(Maybe Text) + , _dType :: !(Maybe DeviceType) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'Device' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'dManufacturer' +-- +-- * 'dUid' +-- +-- * 'dModel' +-- +-- * 'dVersion' +-- +-- * 'dType' +device + :: Device +device = + Device + { _dManufacturer = Nothing + , _dUid = Nothing + , _dModel = Nothing + , _dVersion = Nothing + , _dType = Nothing + } + +-- | Manufacturer of the product\/hardware. +dManufacturer :: Lens' Device (Maybe Text) +dManufacturer + = lens _dManufacturer + (\ s a -> s{_dManufacturer = a}) + +-- | The serial number or other unique ID for the hardware. This field is +-- obfuscated when read by any REST or Android client that did not create +-- the data source. Only the data source creator will see the uid field in +-- clear and normal form. +dUid :: Lens' Device (Maybe Text) +dUid = lens _dUid (\ s a -> s{_dUid = a}) + +-- | End-user visible model name for the device. +dModel :: Lens' Device (Maybe Text) +dModel = lens _dModel (\ s a -> s{_dModel = a}) + +-- | Version string for the device hardware\/software. +dVersion :: Lens' Device (Maybe Text) +dVersion = lens _dVersion (\ s a -> s{_dVersion = a}) + +-- | A constant representing the type of the device. +dType :: Lens' Device (Maybe DeviceType) +dType = lens _dType (\ s a -> s{_dType = a}) + +instance FromJSON Device where + parseJSON + = withObject "Device" + (\ o -> + Device <$> + (o .:? "manufacturer") <*> (o .:? "uid") <*> + (o .:? "model") + <*> (o .:? "version") + <*> (o .:? "type")) + +instance ToJSON Device where + toJSON Device{..} + = object + (catMaybes + [("manufacturer" .=) <$> _dManufacturer, + ("uid" .=) <$> _dUid, ("model" .=) <$> _dModel, + ("version" .=) <$> _dVersion, + ("type" .=) <$> _dType]) + +-- | Holder object for the value of a single field in a data point. A field +-- value has a particular format and is only ever set to one of an integer +-- or a floating point value. +-- +-- /See:/ 'value' smart constructor. +data Value = Value + { _vMapVal :: !(Maybe [ValueMapValEntry]) + , _vFpVal :: !(Maybe (Textual Double)) + , _vIntVal :: !(Maybe (Textual Int32)) + , _vStringVal :: !(Maybe Text) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'Value' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'vMapVal' +-- +-- * 'vFpVal' +-- +-- * 'vIntVal' +-- +-- * 'vStringVal' +value + :: Value +value = + Value + { _vMapVal = Nothing + , _vFpVal = Nothing + , _vIntVal = Nothing + , _vStringVal = Nothing + } + +-- | Map value. The valid key space and units for the corresponding value of +-- each entry should be documented as part of the data type definition. +-- Keys should be kept small whenever possible. Data streams with large +-- keys and high data frequency may be down sampled. +vMapVal :: Lens' Value [ValueMapValEntry] +vMapVal + = lens _vMapVal (\ s a -> s{_vMapVal = a}) . _Default + . _Coerce + +-- | Floating point value. When this is set, other values must not be set. +vFpVal :: Lens' Value (Maybe Double) +vFpVal + = lens _vFpVal (\ s a -> s{_vFpVal = a}) . + mapping _Coerce + +-- | Integer value. When this is set, other values must not be set. +vIntVal :: Lens' Value (Maybe Int32) +vIntVal + = lens _vIntVal (\ s a -> s{_vIntVal = a}) . + mapping _Coerce + +-- | String value. When this is set, other values must not be set. Strings +-- should be kept small whenever possible. Data streams with large string +-- values and high data frequency may be down sampled. +vStringVal :: Lens' Value (Maybe Text) +vStringVal + = lens _vStringVal (\ s a -> s{_vStringVal = a}) + +instance FromJSON Value where + parseJSON + = withObject "Value" + (\ o -> + Value <$> + (o .:? "mapVal" .!= mempty) <*> (o .:? "fpVal") <*> + (o .:? "intVal") + <*> (o .:? "stringVal")) + +instance ToJSON Value where + toJSON Value{..} + = object + (catMaybes + [("mapVal" .=) <$> _vMapVal, + ("fpVal" .=) <$> _vFpVal, ("intVal" .=) <$> _vIntVal, + ("stringVal" .=) <$> _vStringVal]) + +-- +-- /See:/ 'bucketBySession' smart constructor. +newtype BucketBySession = BucketBySession + { _bbsMinDurationMillis :: Maybe (Textual Int64) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'BucketBySession' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'bbsMinDurationMillis' +bucketBySession + :: BucketBySession +bucketBySession = + BucketBySession + { _bbsMinDurationMillis = Nothing + } + +-- | Specifies that only sessions of duration longer than minDurationMillis +-- are considered and used as a container for aggregated data. +bbsMinDurationMillis :: Lens' BucketBySession (Maybe Int64) +bbsMinDurationMillis + = lens _bbsMinDurationMillis + (\ s a -> s{_bbsMinDurationMillis = a}) + . mapping _Coerce + +instance FromJSON BucketBySession where + parseJSON + = withObject "BucketBySession" + (\ o -> + BucketBySession <$> (o .:? "minDurationMillis")) + +instance ToJSON BucketBySession where + toJSON BucketBySession{..} + = object + (catMaybes + [("minDurationMillis" .=) <$> _bbsMinDurationMillis]) + +-- | Represents a single data point, generated by a particular data source. A +-- data point holds a value for each field, an end timestamp and an +-- optional start time. The exact semantics of each of these attributes are +-- specified in the documentation for the particular data type. A data +-- point can represent an instantaneous measurement, reading or input +-- observation, as well as averages or aggregates over a time interval. +-- Check the data type documentation to determine which is the case for a +-- particular data type. Data points always contain one value for each +-- field of the data type. +-- +-- /See:/ 'dataPoint' smart constructor. +data DataPoint = DataPoint + { _dpOriginDataSourceId :: !(Maybe Text) + , _dpRawTimestampNanos :: !(Maybe (Textual Int64)) + , _dpDataTypeName :: !(Maybe Text) + , _dpValue :: !(Maybe [Value]) + , _dpComputationTimeMillis :: !(Maybe (Textual Int64)) + , _dpEndTimeNanos :: !(Maybe (Textual Int64)) + , _dpModifiedTimeMillis :: !(Maybe (Textual Int64)) + , _dpStartTimeNanos :: !(Maybe (Textual Int64)) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DataPoint' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'dpOriginDataSourceId' +-- +-- * 'dpRawTimestampNanos' +-- +-- * 'dpDataTypeName' +-- +-- * 'dpValue' +-- +-- * 'dpComputationTimeMillis' +-- +-- * 'dpEndTimeNanos' +-- +-- * 'dpModifiedTimeMillis' +-- +-- * 'dpStartTimeNanos' +dataPoint + :: DataPoint +dataPoint = + DataPoint + { _dpOriginDataSourceId = Nothing + , _dpRawTimestampNanos = Nothing + , _dpDataTypeName = Nothing + , _dpValue = Nothing + , _dpComputationTimeMillis = Nothing + , _dpEndTimeNanos = Nothing + , _dpModifiedTimeMillis = Nothing + , _dpStartTimeNanos = Nothing + } + +-- | If the data point is contained in a dataset for a derived data source, +-- this field will be populated with the data source stream ID that created +-- the data point originally. +dpOriginDataSourceId :: Lens' DataPoint (Maybe Text) +dpOriginDataSourceId + = lens _dpOriginDataSourceId + (\ s a -> s{_dpOriginDataSourceId = a}) + +-- | The raw timestamp from the original SensorEvent. +dpRawTimestampNanos :: Lens' DataPoint (Maybe Int64) +dpRawTimestampNanos + = lens _dpRawTimestampNanos + (\ s a -> s{_dpRawTimestampNanos = a}) + . mapping _Coerce + +-- | The data type defining the format of the values in this data point. +dpDataTypeName :: Lens' DataPoint (Maybe Text) +dpDataTypeName + = lens _dpDataTypeName + (\ s a -> s{_dpDataTypeName = a}) + +-- | Values of each data type field for the data point. It is expected that +-- each value corresponding to a data type field will occur in the same +-- order that the field is listed with in the data type specified in a data +-- source. Only one of integer and floating point fields will be populated, +-- depending on the format enum value within data source\'s type field. +dpValue :: Lens' DataPoint [Value] +dpValue + = lens _dpValue (\ s a -> s{_dpValue = a}) . _Default + . _Coerce + +-- | Used for version checking during transformation; that is, a datapoint +-- can only replace another datapoint that has an older computation time +-- stamp. +dpComputationTimeMillis :: Lens' DataPoint (Maybe Int64) +dpComputationTimeMillis + = lens _dpComputationTimeMillis + (\ s a -> s{_dpComputationTimeMillis = a}) + . mapping _Coerce + +-- | The end time of the interval represented by this data point, in +-- nanoseconds since epoch. +dpEndTimeNanos :: Lens' DataPoint (Maybe Int64) +dpEndTimeNanos + = lens _dpEndTimeNanos + (\ s a -> s{_dpEndTimeNanos = a}) + . mapping _Coerce + +-- | Indicates the last time this data point was modified. Useful only in +-- contexts where we are listing the data changes, rather than representing +-- the current state of the data. +dpModifiedTimeMillis :: Lens' DataPoint (Maybe Int64) +dpModifiedTimeMillis + = lens _dpModifiedTimeMillis + (\ s a -> s{_dpModifiedTimeMillis = a}) + . mapping _Coerce + +-- | The start time of the interval represented by this data point, in +-- nanoseconds since epoch. +dpStartTimeNanos :: Lens' DataPoint (Maybe Int64) +dpStartTimeNanos + = lens _dpStartTimeNanos + (\ s a -> s{_dpStartTimeNanos = a}) + . mapping _Coerce + +instance FromJSON DataPoint where + parseJSON + = withObject "DataPoint" + (\ o -> + DataPoint <$> + (o .:? "originDataSourceId") <*> + (o .:? "rawTimestampNanos") + <*> (o .:? "dataTypeName") + <*> (o .:? "value" .!= mempty) + <*> (o .:? "computationTimeMillis") + <*> (o .:? "endTimeNanos") + <*> (o .:? "modifiedTimeMillis") + <*> (o .:? "startTimeNanos")) + +instance ToJSON DataPoint where + toJSON DataPoint{..} + = object + (catMaybes + [("originDataSourceId" .=) <$> _dpOriginDataSourceId, + ("rawTimestampNanos" .=) <$> _dpRawTimestampNanos, + ("dataTypeName" .=) <$> _dpDataTypeName, + ("value" .=) <$> _dpValue, + ("computationTimeMillis" .=) <$> + _dpComputationTimeMillis, + ("endTimeNanos" .=) <$> _dpEndTimeNanos, + ("modifiedTimeMillis" .=) <$> _dpModifiedTimeMillis, + ("startTimeNanos" .=) <$> _dpStartTimeNanos]) + +-- +-- /See:/ 'listSessionsResponse' smart constructor. +data ListSessionsResponse = ListSessionsResponse + { _lsrNextPageToken :: !(Maybe Text) + , _lsrDeletedSession :: !(Maybe [Session]) + , _lsrSession :: !(Maybe [Session]) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'ListSessionsResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'lsrNextPageToken' +-- +-- * 'lsrDeletedSession' +-- +-- * 'lsrSession' +listSessionsResponse + :: ListSessionsResponse +listSessionsResponse = + ListSessionsResponse + { _lsrNextPageToken = Nothing + , _lsrDeletedSession = Nothing + , _lsrSession = Nothing + } + +-- | The continuation token, which is used to page through large result sets. +-- Provide this value in a subsequent request to return the next page of +-- results. +lsrNextPageToken :: Lens' ListSessionsResponse (Maybe Text) +lsrNextPageToken + = lens _lsrNextPageToken + (\ s a -> s{_lsrNextPageToken = a}) + +-- | If includeDeleted is set to true in the request, this list will contain +-- sessions deleted with original end times that are within the startTime +-- and endTime frame. +lsrDeletedSession :: Lens' ListSessionsResponse [Session] +lsrDeletedSession + = lens _lsrDeletedSession + (\ s a -> s{_lsrDeletedSession = a}) + . _Default + . _Coerce + +-- | Sessions with an end time that is between startTime and endTime of the +-- request. +lsrSession :: Lens' ListSessionsResponse [Session] +lsrSession + = lens _lsrSession (\ s a -> s{_lsrSession = a}) . + _Default + . _Coerce + +instance FromJSON ListSessionsResponse where + parseJSON + = withObject "ListSessionsResponse" + (\ o -> + ListSessionsResponse <$> + (o .:? "nextPageToken") <*> + (o .:? "deletedSession" .!= mempty) + <*> (o .:? "session" .!= mempty)) + +instance ToJSON ListSessionsResponse where + toJSON ListSessionsResponse{..} + = object + (catMaybes + [("nextPageToken" .=) <$> _lsrNextPageToken, + ("deletedSession" .=) <$> _lsrDeletedSession, + ("session" .=) <$> _lsrSession]) + +-- +-- /See:/ 'aggregateBucket' smart constructor. +data AggregateBucket = AggregateBucket + { _abEndTimeMillis :: !(Maybe (Textual Int64)) + , _abDataSet :: !(Maybe [DataSet]) + , _abActivity :: !(Maybe (Textual Int32)) + , _abType :: !(Maybe AggregateBucketType) + , _abStartTimeMillis :: !(Maybe (Textual Int64)) + , _abSession :: !(Maybe Session) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'AggregateBucket' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'abEndTimeMillis' +-- +-- * 'abDataSet' +-- +-- * 'abActivity' +-- +-- * 'abType' +-- +-- * 'abStartTimeMillis' +-- +-- * 'abSession' +aggregateBucket + :: AggregateBucket +aggregateBucket = + AggregateBucket + { _abEndTimeMillis = Nothing + , _abDataSet = Nothing + , _abActivity = Nothing + , _abType = Nothing + , _abStartTimeMillis = Nothing + , _abSession = Nothing + } + +-- | The end time for the aggregated data, in milliseconds since epoch, +-- inclusive. +abEndTimeMillis :: Lens' AggregateBucket (Maybe Int64) +abEndTimeMillis + = lens _abEndTimeMillis + (\ s a -> s{_abEndTimeMillis = a}) + . mapping _Coerce + +-- | There will be one dataset per AggregateBy in the request. +abDataSet :: Lens' AggregateBucket [DataSet] +abDataSet + = lens _abDataSet (\ s a -> s{_abDataSet = a}) . + _Default + . _Coerce + +-- | Available for Bucket.Type.ACTIVITY_TYPE, Bucket.Type.ACTIVITY_SEGMENT +abActivity :: Lens' AggregateBucket (Maybe Int32) +abActivity + = lens _abActivity (\ s a -> s{_abActivity = a}) . + mapping _Coerce + +-- | The type of a bucket signifies how the data aggregation is performed in +-- the bucket. +abType :: Lens' AggregateBucket (Maybe AggregateBucketType) +abType = lens _abType (\ s a -> s{_abType = a}) + +-- | The start time for the aggregated data, in milliseconds since epoch, +-- inclusive. +abStartTimeMillis :: Lens' AggregateBucket (Maybe Int64) +abStartTimeMillis + = lens _abStartTimeMillis + (\ s a -> s{_abStartTimeMillis = a}) + . mapping _Coerce + +-- | Available for Bucket.Type.SESSION +abSession :: Lens' AggregateBucket (Maybe Session) +abSession + = lens _abSession (\ s a -> s{_abSession = a}) + +instance FromJSON AggregateBucket where + parseJSON + = withObject "AggregateBucket" + (\ o -> + AggregateBucket <$> + (o .:? "endTimeMillis") <*> + (o .:? "dataset" .!= mempty) + <*> (o .:? "activity") + <*> (o .:? "type") + <*> (o .:? "startTimeMillis") + <*> (o .:? "session")) + +instance ToJSON AggregateBucket where + toJSON AggregateBucket{..} + = object + (catMaybes + [("endTimeMillis" .=) <$> _abEndTimeMillis, + ("dataset" .=) <$> _abDataSet, + ("activity" .=) <$> _abActivity, + ("type" .=) <$> _abType, + ("startTimeMillis" .=) <$> _abStartTimeMillis, + ("session" .=) <$> _abSession]) + +-- | Holder object for the value of an entry in a map field of a data point. +-- A map value supports a subset of the formats that the regular Value +-- supports. +-- +-- /See:/ 'mapValue' smart constructor. +newtype MapValue = MapValue + { _mvFpVal :: Maybe (Textual Double) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'MapValue' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'mvFpVal' +mapValue + :: MapValue +mapValue = + MapValue + { _mvFpVal = Nothing + } + +-- | Floating point value. +mvFpVal :: Lens' MapValue (Maybe Double) +mvFpVal + = lens _mvFpVal (\ s a -> s{_mvFpVal = a}) . + mapping _Coerce + +instance FromJSON MapValue where + parseJSON + = withObject "MapValue" + (\ o -> MapValue <$> (o .:? "fpVal")) + +instance ToJSON MapValue where + toJSON MapValue{..} + = object (catMaybes [("fpVal" .=) <$> _mvFpVal]) + +-- +-- /See:/ 'listDataSourcesResponse' smart constructor. +newtype ListDataSourcesResponse = ListDataSourcesResponse + { _ldsrDataSource :: Maybe [DataSource] + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'ListDataSourcesResponse' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'ldsrDataSource' +listDataSourcesResponse + :: ListDataSourcesResponse +listDataSourcesResponse = + ListDataSourcesResponse + { _ldsrDataSource = Nothing + } + +-- | A previously created data source. +ldsrDataSource :: Lens' ListDataSourcesResponse [DataSource] +ldsrDataSource + = lens _ldsrDataSource + (\ s a -> s{_ldsrDataSource = a}) + . _Default + . _Coerce + +instance FromJSON ListDataSourcesResponse where + parseJSON + = withObject "ListDataSourcesResponse" + (\ o -> + ListDataSourcesResponse <$> + (o .:? "dataSource" .!= mempty)) + +instance ToJSON ListDataSourcesResponse where + toJSON ListDataSourcesResponse{..} + = object + (catMaybes [("dataSource" .=) <$> _ldsrDataSource]) + +-- | In case of multi-dimensional data (such as an accelerometer with x, y, +-- and z axes) each field represents one dimension. Each data type field +-- has a unique name which identifies it. The field also defines the format +-- of the data (int, float, etc.). This message is only instantiated in +-- code and not used for wire comms or stored in any way. +-- +-- /See:/ 'dataTypeField' smart constructor. +data DataTypeField = DataTypeField + { _dtfFormat :: !(Maybe DataTypeFieldFormat) + , _dtfName :: !(Maybe Text) + , _dtfOptional :: !(Maybe Bool) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DataTypeField' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'dtfFormat' +-- +-- * 'dtfName' +-- +-- * 'dtfOptional' +dataTypeField + :: DataTypeField +dataTypeField = + DataTypeField + { _dtfFormat = Nothing + , _dtfName = Nothing + , _dtfOptional = Nothing + } + +-- | The different supported formats for each field in a data type. +dtfFormat :: Lens' DataTypeField (Maybe DataTypeFieldFormat) +dtfFormat + = lens _dtfFormat (\ s a -> s{_dtfFormat = a}) + +-- | Defines the name and format of data. Unlike data type names, field names +-- are not namespaced, and only need to be unique within the data type. +dtfName :: Lens' DataTypeField (Maybe Text) +dtfName = lens _dtfName (\ s a -> s{_dtfName = a}) + +dtfOptional :: Lens' DataTypeField (Maybe Bool) +dtfOptional + = lens _dtfOptional (\ s a -> s{_dtfOptional = a}) + +instance FromJSON DataTypeField where + parseJSON + = withObject "DataTypeField" + (\ o -> + DataTypeField <$> + (o .:? "format") <*> (o .:? "name") <*> + (o .:? "optional")) + +instance ToJSON DataTypeField where + toJSON DataTypeField{..} + = object + (catMaybes + [("format" .=) <$> _dtfFormat, + ("name" .=) <$> _dtfName, + ("optional" .=) <$> _dtfOptional]) + +-- | Definition of a unique source of sensor data. Data sources can expose +-- raw data coming from hardware sensors on local or companion devices. +-- They can also expose derived data, created by transforming or merging +-- other data sources. Multiple data sources can exist for the same data +-- type. Every data point inserted into or read from this service has an +-- associated data source. The data source contains enough information to +-- uniquely identify its data, including the hardware device and the +-- application that collected and\/or transformed the data. It also holds +-- useful metadata, such as the hardware and application versions, and the +-- device type. Each data source produces a unique stream of data, with a +-- unique identifier. Not all changes to data source affect the stream +-- identifier, so that data collected by updated versions of the same +-- application\/device can still be considered to belong to the same data +-- stream. +-- +-- /See:/ 'dataSource' smart constructor. +data DataSource = DataSource + { _dsApplication :: !(Maybe Application) + , _dsDevice :: !(Maybe Device) + , _dsName :: !(Maybe Text) + , _dsDataType :: !(Maybe DataType) + , _dsType :: !(Maybe DataSourceType) + , _dsDataStreamName :: !(Maybe Text) + , _dsDataStreamId :: !(Maybe Text) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DataSource' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'dsApplication' +-- +-- * 'dsDevice' +-- +-- * 'dsName' +-- +-- * 'dsDataType' +-- +-- * 'dsType' +-- +-- * 'dsDataStreamName' +-- +-- * 'dsDataStreamId' +dataSource + :: DataSource +dataSource = + DataSource + { _dsApplication = Nothing + , _dsDevice = Nothing + , _dsName = Nothing + , _dsDataType = Nothing + , _dsType = Nothing + , _dsDataStreamName = Nothing + , _dsDataStreamId = Nothing + } + +-- | Information about an application which feeds sensor data into the +-- platform. +dsApplication :: Lens' DataSource (Maybe Application) +dsApplication + = lens _dsApplication + (\ s a -> s{_dsApplication = a}) + +-- | Representation of an integrated device (such as a phone or a wearable) +-- that can hold sensors. +dsDevice :: Lens' DataSource (Maybe Device) +dsDevice = lens _dsDevice (\ s a -> s{_dsDevice = a}) + +-- | An end-user visible name for this data source. +dsName :: Lens' DataSource (Maybe Text) +dsName = lens _dsName (\ s a -> s{_dsName = a}) + +-- | The data type defines the schema for a stream of data being collected +-- by, inserted into, or queried from the Fitness API. +dsDataType :: Lens' DataSource (Maybe DataType) +dsDataType + = lens _dsDataType (\ s a -> s{_dsDataType = a}) + +-- | A constant describing the type of this data source. Indicates whether +-- this data source produces raw or derived data. +dsType :: Lens' DataSource (Maybe DataSourceType) +dsType = lens _dsType (\ s a -> s{_dsType = a}) + +-- | The stream name uniquely identifies this particular data source among +-- other data sources of the same type from the same underlying producer. +-- Setting the stream name is optional, but should be done whenever an +-- application exposes two streams for the same data type, or when a device +-- has two equivalent sensors. +dsDataStreamName :: Lens' DataSource (Maybe Text) +dsDataStreamName + = lens _dsDataStreamName + (\ s a -> s{_dsDataStreamName = a}) + +-- | A unique identifier for the data stream produced by this data source. +-- The identifier includes: - The physical device\'s manufacturer, model, +-- and serial number (UID). - The application\'s package name or name. +-- Package name is used when the data source was created by an Android +-- application. The developer project number is used when the data source +-- was created by a REST client. - The data source\'s type. - The data +-- source\'s stream name. Note that not all attributes of the data source +-- are used as part of the stream identifier. In particular, the version of +-- the hardware\/the application isn\'t used. This allows us to preserve +-- the same stream through version updates. This also means that two +-- DataSource objects may represent the same data stream even if they\'re +-- not equal. The exact format of the data stream ID created by an Android +-- application is: +-- type:dataType.name:application.packageName:device.manufacturer:device.model:device.uid:dataStreamName +-- The exact format of the data stream ID created by a REST client is: +-- type:dataType.name:developer project +-- number:device.manufacturer:device.model:device.uid:dataStreamName When +-- any of the optional fields that comprise of the data stream ID are +-- blank, they will be omitted from the data stream ID. The minnimum viable +-- data stream ID would be: type:dataType.name:developer project number +-- Finally, the developer project number is obfuscated when read by any +-- REST or Android client that did not create the data source. Only the +-- data source creator will see the developer project number in clear and +-- normal form. +dsDataStreamId :: Lens' DataSource (Maybe Text) +dsDataStreamId + = lens _dsDataStreamId + (\ s a -> s{_dsDataStreamId = a}) + +instance FromJSON DataSource where + parseJSON + = withObject "DataSource" + (\ o -> + DataSource <$> + (o .:? "application") <*> (o .:? "device") <*> + (o .:? "name") + <*> (o .:? "dataType") + <*> (o .:? "type") + <*> (o .:? "dataStreamName") + <*> (o .:? "dataStreamId")) + +instance ToJSON DataSource where + toJSON DataSource{..} + = object + (catMaybes + [("application" .=) <$> _dsApplication, + ("device" .=) <$> _dsDevice, ("name" .=) <$> _dsName, + ("dataType" .=) <$> _dsDataType, + ("type" .=) <$> _dsType, + ("dataStreamName" .=) <$> _dsDataStreamName, + ("dataStreamId" .=) <$> _dsDataStreamId]) + +-- +-- /See:/ 'valueMapValEntry' smart constructor. +data ValueMapValEntry = ValueMapValEntry + { _vmveValue :: !(Maybe MapValue) + , _vmveKey :: !(Maybe Text) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'ValueMapValEntry' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'vmveValue' +-- +-- * 'vmveKey' +valueMapValEntry + :: ValueMapValEntry +valueMapValEntry = + ValueMapValEntry + { _vmveValue = Nothing + , _vmveKey = Nothing + } + +vmveValue :: Lens' ValueMapValEntry (Maybe MapValue) +vmveValue + = lens _vmveValue (\ s a -> s{_vmveValue = a}) + +vmveKey :: Lens' ValueMapValEntry (Maybe Text) +vmveKey = lens _vmveKey (\ s a -> s{_vmveKey = a}) + +instance FromJSON ValueMapValEntry where + parseJSON + = withObject "ValueMapValEntry" + (\ o -> + ValueMapValEntry <$> + (o .:? "value") <*> (o .:? "key")) + +instance ToJSON ValueMapValEntry where + toJSON ValueMapValEntry{..} + = object + (catMaybes + [("value" .=) <$> _vmveValue, + ("key" .=) <$> _vmveKey]) + +-- +-- /See:/ 'bucketByTime' smart constructor. +newtype BucketByTime = BucketByTime + { _bbtDurationMillis :: Maybe (Textual Int64) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'BucketByTime' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'bbtDurationMillis' +bucketByTime + :: BucketByTime +bucketByTime = + BucketByTime + { _bbtDurationMillis = Nothing + } + +-- | Specifies that result buckets aggregate data by exactly durationMillis +-- time frames. Time frames that contain no data will be included in the +-- response with an empty dataset. +bbtDurationMillis :: Lens' BucketByTime (Maybe Int64) +bbtDurationMillis + = lens _bbtDurationMillis + (\ s a -> s{_bbtDurationMillis = a}) + . mapping _Coerce + +instance FromJSON BucketByTime where + parseJSON + = withObject "BucketByTime" + (\ o -> BucketByTime <$> (o .:? "durationMillis")) + +instance ToJSON BucketByTime where + toJSON BucketByTime{..} + = object + (catMaybes + [("durationMillis" .=) <$> _bbtDurationMillis]) + +-- | See: +-- google3\/java\/com\/google\/android\/apps\/heart\/platform\/api\/DataType.java +-- +-- /See:/ 'dataType' smart constructor. +data DataType = DataType + { _dtField :: !(Maybe [DataTypeField]) + , _dtName :: !(Maybe Text) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'DataType' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'dtField' +-- +-- * 'dtName' +dataType + :: DataType +dataType = + DataType + { _dtField = Nothing + , _dtName = Nothing + } + +-- | A field represents one dimension of a data type. +dtField :: Lens' DataType [DataTypeField] +dtField + = lens _dtField (\ s a -> s{_dtField = a}) . _Default + . _Coerce + +-- | Each data type has a unique, namespaced, name. All data types in the +-- com.google namespace are shared as part of the platform. +dtName :: Lens' DataType (Maybe Text) +dtName = lens _dtName (\ s a -> s{_dtName = a}) + +instance FromJSON DataType where + parseJSON + = withObject "DataType" + (\ o -> + DataType <$> + (o .:? "field" .!= mempty) <*> (o .:? "name")) + +instance ToJSON DataType where + toJSON DataType{..} + = object + (catMaybes + [("field" .=) <$> _dtField, ("name" .=) <$> _dtName]) + +-- | Sessions contain metadata, such as a user-friendly name and time +-- interval information. +-- +-- /See:/ 'session' smart constructor. +data Session = Session + { _sEndTimeMillis :: !(Maybe (Textual Int64)) + , _sActiveTimeMillis :: !(Maybe (Textual Int64)) + , _sApplication :: !(Maybe Application) + , _sActivityType :: !(Maybe (Textual Int32)) + , _sName :: !(Maybe Text) + , _sModifiedTimeMillis :: !(Maybe (Textual Int64)) + , _sId :: !(Maybe Text) + , _sStartTimeMillis :: !(Maybe (Textual Int64)) + , _sDescription :: !(Maybe Text) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'Session' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'sEndTimeMillis' +-- +-- * 'sActiveTimeMillis' +-- +-- * 'sApplication' +-- +-- * 'sActivityType' +-- +-- * 'sName' +-- +-- * 'sModifiedTimeMillis' +-- +-- * 'sId' +-- +-- * 'sStartTimeMillis' +-- +-- * 'sDescription' +session + :: Session +session = + Session + { _sEndTimeMillis = Nothing + , _sActiveTimeMillis = Nothing + , _sApplication = Nothing + , _sActivityType = Nothing + , _sName = Nothing + , _sModifiedTimeMillis = Nothing + , _sId = Nothing + , _sStartTimeMillis = Nothing + , _sDescription = Nothing + } + +-- | An end time, in milliseconds since epoch, inclusive. +sEndTimeMillis :: Lens' Session (Maybe Int64) +sEndTimeMillis + = lens _sEndTimeMillis + (\ s a -> s{_sEndTimeMillis = a}) + . mapping _Coerce + +-- | Session active time. While start_time_millis and end_time_millis define +-- the full session time, the active time can be shorter and specified by +-- active_time_millis. If the inactive time during the session is known, it +-- should also be inserted via a com.google.activity.segment data point +-- with a STILL activity value +sActiveTimeMillis :: Lens' Session (Maybe Int64) +sActiveTimeMillis + = lens _sActiveTimeMillis + (\ s a -> s{_sActiveTimeMillis = a}) + . mapping _Coerce + +-- | The application that created the session. +sApplication :: Lens' Session (Maybe Application) +sApplication + = lens _sApplication (\ s a -> s{_sApplication = a}) + +-- | The type of activity this session represents. +sActivityType :: Lens' Session (Maybe Int32) +sActivityType + = lens _sActivityType + (\ s a -> s{_sActivityType = a}) + . mapping _Coerce + +-- | A human readable name of the session. +sName :: Lens' Session (Maybe Text) +sName = lens _sName (\ s a -> s{_sName = a}) + +-- | A timestamp that indicates when the session was last modified. +sModifiedTimeMillis :: Lens' Session (Maybe Int64) +sModifiedTimeMillis + = lens _sModifiedTimeMillis + (\ s a -> s{_sModifiedTimeMillis = a}) + . mapping _Coerce + +-- | A client-generated identifier that is unique across all sessions owned +-- by this particular user. +sId :: Lens' Session (Maybe Text) +sId = lens _sId (\ s a -> s{_sId = a}) + +-- | A start time, in milliseconds since epoch, inclusive. +sStartTimeMillis :: Lens' Session (Maybe Int64) +sStartTimeMillis + = lens _sStartTimeMillis + (\ s a -> s{_sStartTimeMillis = a}) + . mapping _Coerce + +-- | A description for this session. +sDescription :: Lens' Session (Maybe Text) +sDescription + = lens _sDescription (\ s a -> s{_sDescription = a}) + +instance FromJSON Session where + parseJSON + = withObject "Session" + (\ o -> + Session <$> + (o .:? "endTimeMillis") <*> + (o .:? "activeTimeMillis") + <*> (o .:? "application") + <*> (o .:? "activityType") + <*> (o .:? "name") + <*> (o .:? "modifiedTimeMillis") + <*> (o .:? "id") + <*> (o .:? "startTimeMillis") + <*> (o .:? "description")) + +instance ToJSON Session where + toJSON Session{..} + = object + (catMaybes + [("endTimeMillis" .=) <$> _sEndTimeMillis, + ("activeTimeMillis" .=) <$> _sActiveTimeMillis, + ("application" .=) <$> _sApplication, + ("activityType" .=) <$> _sActivityType, + ("name" .=) <$> _sName, + ("modifiedTimeMillis" .=) <$> _sModifiedTimeMillis, + ("id" .=) <$> _sId, + ("startTimeMillis" .=) <$> _sStartTimeMillis, + ("description" .=) <$> _sDescription]) diff --git a/gen/Network/Google/Fitness/Types/Sum.hs b/gen/Network/Google/Fitness/Types/Sum.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Fitness/Types/Sum.hs @@ -0,0 +1,173 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} + +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Fitness.Types.Sum +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +module Network.Google.Fitness.Types.Sum where + +import Network.Google.Prelude + +-- | The type of a bucket signifies how the data aggregation is performed in +-- the bucket. +data AggregateBucketType + = ABTActivitySegment + -- ^ @activitySegment@ + | ABTActivityType + -- ^ @activityType@ + | ABTSession + -- ^ @session@ + | ABTTime + -- ^ @time@ + | ABTUnknown + -- ^ @unknown@ + deriving (Eq,Ord,Enum,Read,Show,Data,Typeable,Generic) + +instance Hashable AggregateBucketType + +instance FromText AggregateBucketType where + fromText = \case + "activitySegment" -> Just ABTActivitySegment + "activityType" -> Just ABTActivityType + "session" -> Just ABTSession + "time" -> Just ABTTime + "unknown" -> Just ABTUnknown + _ -> Nothing + +instance ToText AggregateBucketType where + toText = \case + ABTActivitySegment -> "activitySegment" + ABTActivityType -> "activityType" + ABTSession -> "session" + ABTTime -> "time" + ABTUnknown -> "unknown" + +instance FromJSON AggregateBucketType where + parseJSON = parseJSONText "AggregateBucketType" + +instance ToJSON AggregateBucketType where + toJSON = toJSONText + +-- | A constant describing the type of this data source. Indicates whether +-- this data source produces raw or derived data. +data DataSourceType + = Derived + -- ^ @derived@ + | Raw + -- ^ @raw@ + deriving (Eq,Ord,Enum,Read,Show,Data,Typeable,Generic) + +instance Hashable DataSourceType + +instance FromText DataSourceType where + fromText = \case + "derived" -> Just Derived + "raw" -> Just Raw + _ -> Nothing + +instance ToText DataSourceType where + toText = \case + Derived -> "derived" + Raw -> "raw" + +instance FromJSON DataSourceType where + parseJSON = parseJSONText "DataSourceType" + +instance ToJSON DataSourceType where + toJSON = toJSONText + +-- | A constant representing the type of the device. +data DeviceType + = ChestStrap + -- ^ @chestStrap@ + | Phone + -- ^ @phone@ + | Scale + -- ^ @scale@ + | Tablet + -- ^ @tablet@ + | Unknown + -- ^ @unknown@ + | Watch + -- ^ @watch@ + deriving (Eq,Ord,Enum,Read,Show,Data,Typeable,Generic) + +instance Hashable DeviceType + +instance FromText DeviceType where + fromText = \case + "chestStrap" -> Just ChestStrap + "phone" -> Just Phone + "scale" -> Just Scale + "tablet" -> Just Tablet + "unknown" -> Just Unknown + "watch" -> Just Watch + _ -> Nothing + +instance ToText DeviceType where + toText = \case + ChestStrap -> "chestStrap" + Phone -> "phone" + Scale -> "scale" + Tablet -> "tablet" + Unknown -> "unknown" + Watch -> "watch" + +instance FromJSON DeviceType where + parseJSON = parseJSONText "DeviceType" + +instance ToJSON DeviceType where + toJSON = toJSONText + +-- | The different supported formats for each field in a data type. +data DataTypeFieldFormat + = FloatList + -- ^ @floatList@ + | FloatPoint + -- ^ @floatPoint@ + | Integer + -- ^ @integer@ + | IntegerList + -- ^ @integerList@ + | Map + -- ^ @map@ + | String + -- ^ @string@ + deriving (Eq,Ord,Enum,Read,Show,Data,Typeable,Generic) + +instance Hashable DataTypeFieldFormat + +instance FromText DataTypeFieldFormat where + fromText = \case + "floatList" -> Just FloatList + "floatPoint" -> Just FloatPoint + "integer" -> Just Integer + "integerList" -> Just IntegerList + "map" -> Just Map + "string" -> Just String + _ -> Nothing + +instance ToText DataTypeFieldFormat where + toText = \case + FloatList -> "floatList" + FloatPoint -> "floatPoint" + Integer -> "integer" + IntegerList -> "integerList" + Map -> "map" + String -> "string" + +instance FromJSON DataTypeFieldFormat where + parseJSON = parseJSONText "DataTypeFieldFormat" + +instance ToJSON DataTypeFieldFormat where + toJSON = toJSONText diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSet/Aggregate.hs b/gen/Network/Google/Resource/Fitness/Users/DataSet/Aggregate.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSet/Aggregate.hs @@ -0,0 +1,105 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSet.Aggregate +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Aggregates data of a certain type or stream into buckets divided by a +-- given type of boundary. Multiple data sets of multiple types and from +-- multiple sources can be aggreated into exactly one bucket type per +-- request. +-- +-- /See:/ for @fitness.users.dataset.aggregate@. +module Network.Google.Resource.Fitness.Users.DataSet.Aggregate + ( + -- * REST Resource + UsersDataSetAggregateResource + + -- * Creating a Request + , usersDataSetAggregate + , UsersDataSetAggregate + + -- * Request Lenses + , udsaPayload + , udsaUserId + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataset.aggregate@ method which the +-- 'UsersDataSetAggregate' request conforms to. +type UsersDataSetAggregateResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataset:aggregate" :> + QueryParam "alt" AltJSON :> + ReqBody '[JSON] AggregateRequest :> + Post '[JSON] AggregateResponse + +-- | Aggregates data of a certain type or stream into buckets divided by a +-- given type of boundary. Multiple data sets of multiple types and from +-- multiple sources can be aggreated into exactly one bucket type per +-- request. +-- +-- /See:/ 'usersDataSetAggregate' smart constructor. +data UsersDataSetAggregate = UsersDataSetAggregate + { _udsaPayload :: !AggregateRequest + , _udsaUserId :: !Text + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSetAggregate' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udsaPayload' +-- +-- * 'udsaUserId' +usersDataSetAggregate + :: AggregateRequest -- ^ 'udsaPayload' + -> Text -- ^ 'udsaUserId' + -> UsersDataSetAggregate +usersDataSetAggregate pUdsaPayload_ pUdsaUserId_ = + UsersDataSetAggregate + { _udsaPayload = pUdsaPayload_ + , _udsaUserId = pUdsaUserId_ + } + +-- | Multipart request metadata. +udsaPayload :: Lens' UsersDataSetAggregate AggregateRequest +udsaPayload + = lens _udsaPayload (\ s a -> s{_udsaPayload = a}) + +-- | Aggregate data for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udsaUserId :: Lens' UsersDataSetAggregate Text +udsaUserId + = lens _udsaUserId (\ s a -> s{_udsaUserId = a}) + +instance GoogleRequest UsersDataSetAggregate where + type Rs UsersDataSetAggregate = AggregateResponse + requestClient UsersDataSetAggregate{..} + = go _udsaUserId (Just AltJSON) _udsaPayload + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersDataSetAggregateResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSources/Create.hs b/gen/Network/Google/Resource/Fitness/Users/DataSources/Create.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSources/Create.hs @@ -0,0 +1,112 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSources.Create +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Creates a new data source that is unique across all data sources +-- belonging to this user. The data stream ID field can be omitted and will +-- be generated by the server with the correct format. The data stream ID +-- is an ordered combination of some fields from the data source. In +-- addition to the data source fields reflected into the data source ID, +-- the developer project number that is authenticated when creating the +-- data source is included. This developer project number is obfuscated +-- when read by any other developer reading public data types. +-- +-- /See:/ for @fitness.users.dataSources.create@. +module Network.Google.Resource.Fitness.Users.DataSources.Create + ( + -- * REST Resource + UsersDataSourcesCreateResource + + -- * Creating a Request + , usersDataSourcesCreate + , UsersDataSourcesCreate + + -- * Request Lenses + , udscPayload + , udscUserId + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataSources.create@ method which the +-- 'UsersDataSourcesCreate' request conforms to. +type UsersDataSourcesCreateResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataSources" :> + QueryParam "alt" AltJSON :> + ReqBody '[JSON] DataSource :> Post '[JSON] DataSource + +-- | Creates a new data source that is unique across all data sources +-- belonging to this user. The data stream ID field can be omitted and will +-- be generated by the server with the correct format. The data stream ID +-- is an ordered combination of some fields from the data source. In +-- addition to the data source fields reflected into the data source ID, +-- the developer project number that is authenticated when creating the +-- data source is included. This developer project number is obfuscated +-- when read by any other developer reading public data types. +-- +-- /See:/ 'usersDataSourcesCreate' smart constructor. +data UsersDataSourcesCreate = UsersDataSourcesCreate + { _udscPayload :: !DataSource + , _udscUserId :: !Text + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSourcesCreate' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udscPayload' +-- +-- * 'udscUserId' +usersDataSourcesCreate + :: DataSource -- ^ 'udscPayload' + -> Text -- ^ 'udscUserId' + -> UsersDataSourcesCreate +usersDataSourcesCreate pUdscPayload_ pUdscUserId_ = + UsersDataSourcesCreate + { _udscPayload = pUdscPayload_ + , _udscUserId = pUdscUserId_ + } + +-- | Multipart request metadata. +udscPayload :: Lens' UsersDataSourcesCreate DataSource +udscPayload + = lens _udscPayload (\ s a -> s{_udscPayload = a}) + +-- | Create the data source for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udscUserId :: Lens' UsersDataSourcesCreate Text +udscUserId + = lens _udscUserId (\ s a -> s{_udscUserId = a}) + +instance GoogleRequest UsersDataSourcesCreate where + type Rs UsersDataSourcesCreate = DataSource + requestClient UsersDataSourcesCreate{..} + = go _udscUserId (Just AltJSON) _udscPayload + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersDataSourcesCreateResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSources/DataSets/Delete.hs b/gen/Network/Google/Resource/Fitness/Users/DataSources/DataSets/Delete.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSources/DataSets/Delete.hs @@ -0,0 +1,160 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSources.DataSets.Delete +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Performs an inclusive delete of all data points whose start and end +-- times have any overlap with the time range specified by the dataset ID. +-- For most data types, the entire data point will be deleted. For data +-- types where the time span represents a consistent value (such as +-- com.google.activity.segment), and a data point straddles either end +-- point of the dataset, only the overlapping portion of the data point +-- will be deleted. +-- +-- /See:/ for @fitness.users.dataSources.datasets.delete@. +module Network.Google.Resource.Fitness.Users.DataSources.DataSets.Delete + ( + -- * REST Resource + UsersDataSourcesDataSetsDeleteResource + + -- * Creating a Request + , usersDataSourcesDataSetsDelete + , UsersDataSourcesDataSetsDelete + + -- * Request Lenses + , udsdsdDataSourceId + , udsdsdUserId + , udsdsdDataSetId + , udsdsdModifiedTimeMillis + , udsdsdCurrentTimeMillis + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataSources.datasets.delete@ method which the +-- 'UsersDataSourcesDataSetsDelete' request conforms to. +type UsersDataSourcesDataSetsDeleteResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataSources" :> + Capture "dataSourceId" Text :> + "datasets" :> + Capture "datasetId" Text :> + QueryParam "modifiedTimeMillis" (Textual Int64) :> + QueryParam "currentTimeMillis" (Textual Int64) :> + QueryParam "alt" AltJSON :> Delete '[JSON] () + +-- | Performs an inclusive delete of all data points whose start and end +-- times have any overlap with the time range specified by the dataset ID. +-- For most data types, the entire data point will be deleted. For data +-- types where the time span represents a consistent value (such as +-- com.google.activity.segment), and a data point straddles either end +-- point of the dataset, only the overlapping portion of the data point +-- will be deleted. +-- +-- /See:/ 'usersDataSourcesDataSetsDelete' smart constructor. +data UsersDataSourcesDataSetsDelete = UsersDataSourcesDataSetsDelete + { _udsdsdDataSourceId :: !Text + , _udsdsdUserId :: !Text + , _udsdsdDataSetId :: !Text + , _udsdsdModifiedTimeMillis :: !(Maybe (Textual Int64)) + , _udsdsdCurrentTimeMillis :: !(Maybe (Textual Int64)) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSourcesDataSetsDelete' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udsdsdDataSourceId' +-- +-- * 'udsdsdUserId' +-- +-- * 'udsdsdDataSetId' +-- +-- * 'udsdsdModifiedTimeMillis' +-- +-- * 'udsdsdCurrentTimeMillis' +usersDataSourcesDataSetsDelete + :: Text -- ^ 'udsdsdDataSourceId' + -> Text -- ^ 'udsdsdUserId' + -> Text -- ^ 'udsdsdDataSetId' + -> UsersDataSourcesDataSetsDelete +usersDataSourcesDataSetsDelete pUdsdsdDataSourceId_ pUdsdsdUserId_ pUdsdsdDataSetId_ = + UsersDataSourcesDataSetsDelete + { _udsdsdDataSourceId = pUdsdsdDataSourceId_ + , _udsdsdUserId = pUdsdsdUserId_ + , _udsdsdDataSetId = pUdsdsdDataSetId_ + , _udsdsdModifiedTimeMillis = Nothing + , _udsdsdCurrentTimeMillis = Nothing + } + +-- | The data stream ID of the data source that created the dataset. +udsdsdDataSourceId :: Lens' UsersDataSourcesDataSetsDelete Text +udsdsdDataSourceId + = lens _udsdsdDataSourceId + (\ s a -> s{_udsdsdDataSourceId = a}) + +-- | Delete a dataset for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udsdsdUserId :: Lens' UsersDataSourcesDataSetsDelete Text +udsdsdUserId + = lens _udsdsdUserId (\ s a -> s{_udsdsdUserId = a}) + +-- | Dataset identifier that is a composite of the minimum data point start +-- time and maximum data point end time represented as nanoseconds from the +-- epoch. The ID is formatted like: \"startTime-endTime\" where startTime +-- and endTime are 64 bit integers. +udsdsdDataSetId :: Lens' UsersDataSourcesDataSetsDelete Text +udsdsdDataSetId + = lens _udsdsdDataSetId + (\ s a -> s{_udsdsdDataSetId = a}) + +-- | When the operation was performed on the client. +udsdsdModifiedTimeMillis :: Lens' UsersDataSourcesDataSetsDelete (Maybe Int64) +udsdsdModifiedTimeMillis + = lens _udsdsdModifiedTimeMillis + (\ s a -> s{_udsdsdModifiedTimeMillis = a}) + . mapping _Coerce + +-- | The client\'s current time in milliseconds since epoch. +udsdsdCurrentTimeMillis :: Lens' UsersDataSourcesDataSetsDelete (Maybe Int64) +udsdsdCurrentTimeMillis + = lens _udsdsdCurrentTimeMillis + (\ s a -> s{_udsdsdCurrentTimeMillis = a}) + . mapping _Coerce + +instance GoogleRequest UsersDataSourcesDataSetsDelete + where + type Rs UsersDataSourcesDataSetsDelete = () + requestClient UsersDataSourcesDataSetsDelete{..} + = go _udsdsdUserId _udsdsdDataSourceId + _udsdsdDataSetId + _udsdsdModifiedTimeMillis + _udsdsdCurrentTimeMillis + (Just AltJSON) + fitnessService + where go + = buildClient + (Proxy :: + Proxy UsersDataSourcesDataSetsDeleteResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSources/DataSets/Get.hs b/gen/Network/Google/Resource/Fitness/Users/DataSources/DataSets/Get.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSources/DataSets/Get.hs @@ -0,0 +1,159 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSources.DataSets.Get +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Returns a dataset containing all data points whose start and end times +-- overlap with the specified range of the dataset minimum start time and +-- maximum end time. Specifically, any data point whose start time is less +-- than or equal to the dataset end time and whose end time is greater than +-- or equal to the dataset start time. +-- +-- /See:/ for @fitness.users.dataSources.datasets.get@. +module Network.Google.Resource.Fitness.Users.DataSources.DataSets.Get + ( + -- * REST Resource + UsersDataSourcesDataSetsGetResource + + -- * Creating a Request + , usersDataSourcesDataSetsGet + , UsersDataSourcesDataSetsGet + + -- * Request Lenses + , udsdsgDataSourceId + , udsdsgUserId + , udsdsgDataSetId + , udsdsgLimit + , udsdsgPageToken + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataSources.datasets.get@ method which the +-- 'UsersDataSourcesDataSetsGet' request conforms to. +type UsersDataSourcesDataSetsGetResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataSources" :> + Capture "dataSourceId" Text :> + "datasets" :> + Capture "datasetId" Text :> + QueryParam "limit" (Textual Int32) :> + QueryParam "pageToken" Text :> + QueryParam "alt" AltJSON :> Get '[JSON] DataSet + +-- | Returns a dataset containing all data points whose start and end times +-- overlap with the specified range of the dataset minimum start time and +-- maximum end time. Specifically, any data point whose start time is less +-- than or equal to the dataset end time and whose end time is greater than +-- or equal to the dataset start time. +-- +-- /See:/ 'usersDataSourcesDataSetsGet' smart constructor. +data UsersDataSourcesDataSetsGet = UsersDataSourcesDataSetsGet + { _udsdsgDataSourceId :: !Text + , _udsdsgUserId :: !Text + , _udsdsgDataSetId :: !Text + , _udsdsgLimit :: !(Maybe (Textual Int32)) + , _udsdsgPageToken :: !(Maybe Text) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSourcesDataSetsGet' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udsdsgDataSourceId' +-- +-- * 'udsdsgUserId' +-- +-- * 'udsdsgDataSetId' +-- +-- * 'udsdsgLimit' +-- +-- * 'udsdsgPageToken' +usersDataSourcesDataSetsGet + :: Text -- ^ 'udsdsgDataSourceId' + -> Text -- ^ 'udsdsgUserId' + -> Text -- ^ 'udsdsgDataSetId' + -> UsersDataSourcesDataSetsGet +usersDataSourcesDataSetsGet pUdsdsgDataSourceId_ pUdsdsgUserId_ pUdsdsgDataSetId_ = + UsersDataSourcesDataSetsGet + { _udsdsgDataSourceId = pUdsdsgDataSourceId_ + , _udsdsgUserId = pUdsdsgUserId_ + , _udsdsgDataSetId = pUdsdsgDataSetId_ + , _udsdsgLimit = Nothing + , _udsdsgPageToken = Nothing + } + +-- | The data stream ID of the data source that created the dataset. +udsdsgDataSourceId :: Lens' UsersDataSourcesDataSetsGet Text +udsdsgDataSourceId + = lens _udsdsgDataSourceId + (\ s a -> s{_udsdsgDataSourceId = a}) + +-- | Retrieve a dataset for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udsdsgUserId :: Lens' UsersDataSourcesDataSetsGet Text +udsdsgUserId + = lens _udsdsgUserId (\ s a -> s{_udsdsgUserId = a}) + +-- | Dataset identifier that is a composite of the minimum data point start +-- time and maximum data point end time represented as nanoseconds from the +-- epoch. The ID is formatted like: \"startTime-endTime\" where startTime +-- and endTime are 64 bit integers. +udsdsgDataSetId :: Lens' UsersDataSourcesDataSetsGet Text +udsdsgDataSetId + = lens _udsdsgDataSetId + (\ s a -> s{_udsdsgDataSetId = a}) + +-- | If specified, no more than this many data points will be included in the +-- dataset. If the there are more data points in the dataset, nextPageToken +-- will be set in the dataset response. +udsdsgLimit :: Lens' UsersDataSourcesDataSetsGet (Maybe Int32) +udsdsgLimit + = lens _udsdsgLimit (\ s a -> s{_udsdsgLimit = a}) . + mapping _Coerce + +-- | The continuation token, which is used to page through large datasets. To +-- get the next page of a dataset, set this parameter to the value of +-- nextPageToken from the previous response. Each subsequent call will +-- yield a partial dataset with data point end timestamps that are strictly +-- smaller than those in the previous partial response. +udsdsgPageToken :: Lens' UsersDataSourcesDataSetsGet (Maybe Text) +udsdsgPageToken + = lens _udsdsgPageToken + (\ s a -> s{_udsdsgPageToken = a}) + +instance GoogleRequest UsersDataSourcesDataSetsGet + where + type Rs UsersDataSourcesDataSetsGet = DataSet + requestClient UsersDataSourcesDataSetsGet{..} + = go _udsdsgUserId _udsdsgDataSourceId + _udsdsgDataSetId + _udsdsgLimit + _udsdsgPageToken + (Just AltJSON) + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersDataSourcesDataSetsGetResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSources/DataSets/Patch.hs b/gen/Network/Google/Resource/Fitness/Users/DataSources/DataSets/Patch.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSources/DataSets/Patch.hs @@ -0,0 +1,156 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSources.DataSets.Patch +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Adds data points to a dataset. The dataset need not be previously +-- created. All points within the given dataset will be returned with +-- subsquent calls to retrieve this dataset. Data points can belong to more +-- than one dataset. This method does not use patch semantics. +-- +-- /See:/ for @fitness.users.dataSources.datasets.patch@. +module Network.Google.Resource.Fitness.Users.DataSources.DataSets.Patch + ( + -- * REST Resource + UsersDataSourcesDataSetsPatchResource + + -- * Creating a Request + , usersDataSourcesDataSetsPatch + , UsersDataSourcesDataSetsPatch + + -- * Request Lenses + , udsdspDataSourceId + , udsdspPayload + , udsdspUserId + , udsdspDataSetId + , udsdspCurrentTimeMillis + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataSources.datasets.patch@ method which the +-- 'UsersDataSourcesDataSetsPatch' request conforms to. +type UsersDataSourcesDataSetsPatchResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataSources" :> + Capture "dataSourceId" Text :> + "datasets" :> + Capture "datasetId" Text :> + QueryParam "currentTimeMillis" (Textual Int64) :> + QueryParam "alt" AltJSON :> + ReqBody '[JSON] DataSet :> Patch '[JSON] DataSet + +-- | Adds data points to a dataset. The dataset need not be previously +-- created. All points within the given dataset will be returned with +-- subsquent calls to retrieve this dataset. Data points can belong to more +-- than one dataset. This method does not use patch semantics. +-- +-- /See:/ 'usersDataSourcesDataSetsPatch' smart constructor. +data UsersDataSourcesDataSetsPatch = UsersDataSourcesDataSetsPatch + { _udsdspDataSourceId :: !Text + , _udsdspPayload :: !DataSet + , _udsdspUserId :: !Text + , _udsdspDataSetId :: !Text + , _udsdspCurrentTimeMillis :: !(Maybe (Textual Int64)) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSourcesDataSetsPatch' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udsdspDataSourceId' +-- +-- * 'udsdspPayload' +-- +-- * 'udsdspUserId' +-- +-- * 'udsdspDataSetId' +-- +-- * 'udsdspCurrentTimeMillis' +usersDataSourcesDataSetsPatch + :: Text -- ^ 'udsdspDataSourceId' + -> DataSet -- ^ 'udsdspPayload' + -> Text -- ^ 'udsdspUserId' + -> Text -- ^ 'udsdspDataSetId' + -> UsersDataSourcesDataSetsPatch +usersDataSourcesDataSetsPatch pUdsdspDataSourceId_ pUdsdspPayload_ pUdsdspUserId_ pUdsdspDataSetId_ = + UsersDataSourcesDataSetsPatch + { _udsdspDataSourceId = pUdsdspDataSourceId_ + , _udsdspPayload = pUdsdspPayload_ + , _udsdspUserId = pUdsdspUserId_ + , _udsdspDataSetId = pUdsdspDataSetId_ + , _udsdspCurrentTimeMillis = Nothing + } + +-- | The data stream ID of the data source that created the dataset. +udsdspDataSourceId :: Lens' UsersDataSourcesDataSetsPatch Text +udsdspDataSourceId + = lens _udsdspDataSourceId + (\ s a -> s{_udsdspDataSourceId = a}) + +-- | Multipart request metadata. +udsdspPayload :: Lens' UsersDataSourcesDataSetsPatch DataSet +udsdspPayload + = lens _udsdspPayload + (\ s a -> s{_udsdspPayload = a}) + +-- | Patch a dataset for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udsdspUserId :: Lens' UsersDataSourcesDataSetsPatch Text +udsdspUserId + = lens _udsdspUserId (\ s a -> s{_udsdspUserId = a}) + +-- | Dataset identifier that is a composite of the minimum data point start +-- time and maximum data point end time represented as nanoseconds from the +-- epoch. The ID is formatted like: \"startTime-endTime\" where startTime +-- and endTime are 64 bit integers. +udsdspDataSetId :: Lens' UsersDataSourcesDataSetsPatch Text +udsdspDataSetId + = lens _udsdspDataSetId + (\ s a -> s{_udsdspDataSetId = a}) + +-- | The client\'s current time in milliseconds since epoch. Note that the +-- minStartTimeNs and maxEndTimeNs properties in the request body are in +-- nanoseconds instead of milliseconds. +udsdspCurrentTimeMillis :: Lens' UsersDataSourcesDataSetsPatch (Maybe Int64) +udsdspCurrentTimeMillis + = lens _udsdspCurrentTimeMillis + (\ s a -> s{_udsdspCurrentTimeMillis = a}) + . mapping _Coerce + +instance GoogleRequest UsersDataSourcesDataSetsPatch + where + type Rs UsersDataSourcesDataSetsPatch = DataSet + requestClient UsersDataSourcesDataSetsPatch{..} + = go _udsdspUserId _udsdspDataSourceId + _udsdspDataSetId + _udsdspCurrentTimeMillis + (Just AltJSON) + _udsdspPayload + fitnessService + where go + = buildClient + (Proxy :: + Proxy UsersDataSourcesDataSetsPatchResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSources/Delete.hs b/gen/Network/Google/Resource/Fitness/Users/DataSources/Delete.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSources/Delete.hs @@ -0,0 +1,99 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSources.Delete +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Delete the data source if there are no datapoints associated with it +-- +-- /See:/ for @fitness.users.dataSources.delete@. +module Network.Google.Resource.Fitness.Users.DataSources.Delete + ( + -- * REST Resource + UsersDataSourcesDeleteResource + + -- * Creating a Request + , usersDataSourcesDelete + , UsersDataSourcesDelete + + -- * Request Lenses + , udsdDataSourceId + , udsdUserId + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataSources.delete@ method which the +-- 'UsersDataSourcesDelete' request conforms to. +type UsersDataSourcesDeleteResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataSources" :> + Capture "dataSourceId" Text :> + QueryParam "alt" AltJSON :> Delete '[JSON] DataSource + +-- | Delete the data source if there are no datapoints associated with it +-- +-- /See:/ 'usersDataSourcesDelete' smart constructor. +data UsersDataSourcesDelete = UsersDataSourcesDelete + { _udsdDataSourceId :: !Text + , _udsdUserId :: !Text + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSourcesDelete' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udsdDataSourceId' +-- +-- * 'udsdUserId' +usersDataSourcesDelete + :: Text -- ^ 'udsdDataSourceId' + -> Text -- ^ 'udsdUserId' + -> UsersDataSourcesDelete +usersDataSourcesDelete pUdsdDataSourceId_ pUdsdUserId_ = + UsersDataSourcesDelete + { _udsdDataSourceId = pUdsdDataSourceId_ + , _udsdUserId = pUdsdUserId_ + } + +-- | The data stream ID of the data source to delete. +udsdDataSourceId :: Lens' UsersDataSourcesDelete Text +udsdDataSourceId + = lens _udsdDataSourceId + (\ s a -> s{_udsdDataSourceId = a}) + +-- | Retrieve a data source for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udsdUserId :: Lens' UsersDataSourcesDelete Text +udsdUserId + = lens _udsdUserId (\ s a -> s{_udsdUserId = a}) + +instance GoogleRequest UsersDataSourcesDelete where + type Rs UsersDataSourcesDelete = DataSource + requestClient UsersDataSourcesDelete{..} + = go _udsdUserId _udsdDataSourceId (Just AltJSON) + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersDataSourcesDeleteResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSources/Get.hs b/gen/Network/Google/Resource/Fitness/Users/DataSources/Get.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSources/Get.hs @@ -0,0 +1,99 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSources.Get +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Returns a data source identified by a data stream ID. +-- +-- /See:/ for @fitness.users.dataSources.get@. +module Network.Google.Resource.Fitness.Users.DataSources.Get + ( + -- * REST Resource + UsersDataSourcesGetResource + + -- * Creating a Request + , usersDataSourcesGet + , UsersDataSourcesGet + + -- * Request Lenses + , udsgDataSourceId + , udsgUserId + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataSources.get@ method which the +-- 'UsersDataSourcesGet' request conforms to. +type UsersDataSourcesGetResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataSources" :> + Capture "dataSourceId" Text :> + QueryParam "alt" AltJSON :> Get '[JSON] DataSource + +-- | Returns a data source identified by a data stream ID. +-- +-- /See:/ 'usersDataSourcesGet' smart constructor. +data UsersDataSourcesGet = UsersDataSourcesGet + { _udsgDataSourceId :: !Text + , _udsgUserId :: !Text + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSourcesGet' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udsgDataSourceId' +-- +-- * 'udsgUserId' +usersDataSourcesGet + :: Text -- ^ 'udsgDataSourceId' + -> Text -- ^ 'udsgUserId' + -> UsersDataSourcesGet +usersDataSourcesGet pUdsgDataSourceId_ pUdsgUserId_ = + UsersDataSourcesGet + { _udsgDataSourceId = pUdsgDataSourceId_ + , _udsgUserId = pUdsgUserId_ + } + +-- | The data stream ID of the data source to retrieve. +udsgDataSourceId :: Lens' UsersDataSourcesGet Text +udsgDataSourceId + = lens _udsgDataSourceId + (\ s a -> s{_udsgDataSourceId = a}) + +-- | Retrieve a data source for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udsgUserId :: Lens' UsersDataSourcesGet Text +udsgUserId + = lens _udsgUserId (\ s a -> s{_udsgUserId = a}) + +instance GoogleRequest UsersDataSourcesGet where + type Rs UsersDataSourcesGet = DataSource + requestClient UsersDataSourcesGet{..} + = go _udsgUserId _udsgDataSourceId (Just AltJSON) + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersDataSourcesGetResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSources/List.hs b/gen/Network/Google/Resource/Fitness/Users/DataSources/List.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSources/List.hs @@ -0,0 +1,110 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSources.List +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Lists all data sources that are visible to the developer, using the +-- OAuth scopes provided. The list is not exhaustive: the user may have +-- private data sources that are only visible to other developers or calls +-- using other scopes. +-- +-- /See:/ for @fitness.users.dataSources.list@. +module Network.Google.Resource.Fitness.Users.DataSources.List + ( + -- * REST Resource + UsersDataSourcesListResource + + -- * Creating a Request + , usersDataSourcesList + , UsersDataSourcesList + + -- * Request Lenses + , udslDataTypeName + , udslUserId + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataSources.list@ method which the +-- 'UsersDataSourcesList' request conforms to. +type UsersDataSourcesListResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataSources" :> + QueryParams "dataTypeName" Text :> + QueryParam "alt" AltJSON :> + Get '[JSON] ListDataSourcesResponse + +-- | Lists all data sources that are visible to the developer, using the +-- OAuth scopes provided. The list is not exhaustive: the user may have +-- private data sources that are only visible to other developers or calls +-- using other scopes. +-- +-- /See:/ 'usersDataSourcesList' smart constructor. +data UsersDataSourcesList = UsersDataSourcesList + { _udslDataTypeName :: !(Maybe [Text]) + , _udslUserId :: !Text + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSourcesList' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udslDataTypeName' +-- +-- * 'udslUserId' +usersDataSourcesList + :: Text -- ^ 'udslUserId' + -> UsersDataSourcesList +usersDataSourcesList pUdslUserId_ = + UsersDataSourcesList + { _udslDataTypeName = Nothing + , _udslUserId = pUdslUserId_ + } + +-- | The names of data types to include in the list. If not specified, all +-- data sources will be returned. +udslDataTypeName :: Lens' UsersDataSourcesList [Text] +udslDataTypeName + = lens _udslDataTypeName + (\ s a -> s{_udslDataTypeName = a}) + . _Default + . _Coerce + +-- | List data sources for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udslUserId :: Lens' UsersDataSourcesList Text +udslUserId + = lens _udslUserId (\ s a -> s{_udslUserId = a}) + +instance GoogleRequest UsersDataSourcesList where + type Rs UsersDataSourcesList = + ListDataSourcesResponse + requestClient UsersDataSourcesList{..} + = go _udslUserId (_udslDataTypeName ^. _Default) + (Just AltJSON) + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersDataSourcesListResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSources/Patch.hs b/gen/Network/Google/Resource/Fitness/Users/DataSources/Patch.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSources/Patch.hs @@ -0,0 +1,123 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSources.Patch +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Updates a given data source. It is an error to modify the data source\'s +-- data stream ID, data type, type, stream name or device information apart +-- from the device version. Changing these fields would require a new +-- unique data stream ID and separate data source. Data sources are +-- identified by their data stream ID. This method supports patch +-- semantics. +-- +-- /See:/ for @fitness.users.dataSources.patch@. +module Network.Google.Resource.Fitness.Users.DataSources.Patch + ( + -- * REST Resource + UsersDataSourcesPatchResource + + -- * Creating a Request + , usersDataSourcesPatch + , UsersDataSourcesPatch + + -- * Request Lenses + , udspDataSourceId + , udspPayload + , udspUserId + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataSources.patch@ method which the +-- 'UsersDataSourcesPatch' request conforms to. +type UsersDataSourcesPatchResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataSources" :> + Capture "dataSourceId" Text :> + QueryParam "alt" AltJSON :> + ReqBody '[JSON] DataSource :> + Patch '[JSON] DataSource + +-- | Updates a given data source. It is an error to modify the data source\'s +-- data stream ID, data type, type, stream name or device information apart +-- from the device version. Changing these fields would require a new +-- unique data stream ID and separate data source. Data sources are +-- identified by their data stream ID. This method supports patch +-- semantics. +-- +-- /See:/ 'usersDataSourcesPatch' smart constructor. +data UsersDataSourcesPatch = UsersDataSourcesPatch + { _udspDataSourceId :: !Text + , _udspPayload :: !DataSource + , _udspUserId :: !Text + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSourcesPatch' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udspDataSourceId' +-- +-- * 'udspPayload' +-- +-- * 'udspUserId' +usersDataSourcesPatch + :: Text -- ^ 'udspDataSourceId' + -> DataSource -- ^ 'udspPayload' + -> Text -- ^ 'udspUserId' + -> UsersDataSourcesPatch +usersDataSourcesPatch pUdspDataSourceId_ pUdspPayload_ pUdspUserId_ = + UsersDataSourcesPatch + { _udspDataSourceId = pUdspDataSourceId_ + , _udspPayload = pUdspPayload_ + , _udspUserId = pUdspUserId_ + } + +-- | The data stream ID of the data source to update. +udspDataSourceId :: Lens' UsersDataSourcesPatch Text +udspDataSourceId + = lens _udspDataSourceId + (\ s a -> s{_udspDataSourceId = a}) + +-- | Multipart request metadata. +udspPayload :: Lens' UsersDataSourcesPatch DataSource +udspPayload + = lens _udspPayload (\ s a -> s{_udspPayload = a}) + +-- | Update the data source for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udspUserId :: Lens' UsersDataSourcesPatch Text +udspUserId + = lens _udspUserId (\ s a -> s{_udspUserId = a}) + +instance GoogleRequest UsersDataSourcesPatch where + type Rs UsersDataSourcesPatch = DataSource + requestClient UsersDataSourcesPatch{..} + = go _udspUserId _udspDataSourceId (Just AltJSON) + _udspPayload + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersDataSourcesPatchResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/DataSources/Update.hs b/gen/Network/Google/Resource/Fitness/Users/DataSources/Update.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/DataSources/Update.hs @@ -0,0 +1,120 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.DataSources.Update +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Updates a given data source. It is an error to modify the data source\'s +-- data stream ID, data type, type, stream name or device information apart +-- from the device version. Changing these fields would require a new +-- unique data stream ID and separate data source. Data sources are +-- identified by their data stream ID. +-- +-- /See:/ for @fitness.users.dataSources.update@. +module Network.Google.Resource.Fitness.Users.DataSources.Update + ( + -- * REST Resource + UsersDataSourcesUpdateResource + + -- * Creating a Request + , usersDataSourcesUpdate + , UsersDataSourcesUpdate + + -- * Request Lenses + , udsuDataSourceId + , udsuPayload + , udsuUserId + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.dataSources.update@ method which the +-- 'UsersDataSourcesUpdate' request conforms to. +type UsersDataSourcesUpdateResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "dataSources" :> + Capture "dataSourceId" Text :> + QueryParam "alt" AltJSON :> + ReqBody '[JSON] DataSource :> Put '[JSON] DataSource + +-- | Updates a given data source. It is an error to modify the data source\'s +-- data stream ID, data type, type, stream name or device information apart +-- from the device version. Changing these fields would require a new +-- unique data stream ID and separate data source. Data sources are +-- identified by their data stream ID. +-- +-- /See:/ 'usersDataSourcesUpdate' smart constructor. +data UsersDataSourcesUpdate = UsersDataSourcesUpdate + { _udsuDataSourceId :: !Text + , _udsuPayload :: !DataSource + , _udsuUserId :: !Text + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersDataSourcesUpdate' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'udsuDataSourceId' +-- +-- * 'udsuPayload' +-- +-- * 'udsuUserId' +usersDataSourcesUpdate + :: Text -- ^ 'udsuDataSourceId' + -> DataSource -- ^ 'udsuPayload' + -> Text -- ^ 'udsuUserId' + -> UsersDataSourcesUpdate +usersDataSourcesUpdate pUdsuDataSourceId_ pUdsuPayload_ pUdsuUserId_ = + UsersDataSourcesUpdate + { _udsuDataSourceId = pUdsuDataSourceId_ + , _udsuPayload = pUdsuPayload_ + , _udsuUserId = pUdsuUserId_ + } + +-- | The data stream ID of the data source to update. +udsuDataSourceId :: Lens' UsersDataSourcesUpdate Text +udsuDataSourceId + = lens _udsuDataSourceId + (\ s a -> s{_udsuDataSourceId = a}) + +-- | Multipart request metadata. +udsuPayload :: Lens' UsersDataSourcesUpdate DataSource +udsuPayload + = lens _udsuPayload (\ s a -> s{_udsuPayload = a}) + +-- | Update the data source for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +udsuUserId :: Lens' UsersDataSourcesUpdate Text +udsuUserId + = lens _udsuUserId (\ s a -> s{_udsuUserId = a}) + +instance GoogleRequest UsersDataSourcesUpdate where + type Rs UsersDataSourcesUpdate = DataSource + requestClient UsersDataSourcesUpdate{..} + = go _udsuUserId _udsuDataSourceId (Just AltJSON) + _udsuPayload + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersDataSourcesUpdateResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/Sessions/Delete.hs b/gen/Network/Google/Resource/Fitness/Users/Sessions/Delete.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/Sessions/Delete.hs @@ -0,0 +1,112 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.Sessions.Delete +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Deletes a session specified by the given session ID. +-- +-- /See:/ for @fitness.users.sessions.delete@. +module Network.Google.Resource.Fitness.Users.Sessions.Delete + ( + -- * REST Resource + UsersSessionsDeleteResource + + -- * Creating a Request + , usersSessionsDelete + , UsersSessionsDelete + + -- * Request Lenses + , usdUserId + , usdCurrentTimeMillis + , usdSessionId + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.sessions.delete@ method which the +-- 'UsersSessionsDelete' request conforms to. +type UsersSessionsDeleteResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "sessions" :> + Capture "sessionId" Text :> + QueryParam "currentTimeMillis" (Textual Int64) :> + QueryParam "alt" AltJSON :> Delete '[JSON] () + +-- | Deletes a session specified by the given session ID. +-- +-- /See:/ 'usersSessionsDelete' smart constructor. +data UsersSessionsDelete = UsersSessionsDelete + { _usdUserId :: !Text + , _usdCurrentTimeMillis :: !(Maybe (Textual Int64)) + , _usdSessionId :: !Text + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersSessionsDelete' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'usdUserId' +-- +-- * 'usdCurrentTimeMillis' +-- +-- * 'usdSessionId' +usersSessionsDelete + :: Text -- ^ 'usdUserId' + -> Text -- ^ 'usdSessionId' + -> UsersSessionsDelete +usersSessionsDelete pUsdUserId_ pUsdSessionId_ = + UsersSessionsDelete + { _usdUserId = pUsdUserId_ + , _usdCurrentTimeMillis = Nothing + , _usdSessionId = pUsdSessionId_ + } + +-- | Delete a session for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +usdUserId :: Lens' UsersSessionsDelete Text +usdUserId + = lens _usdUserId (\ s a -> s{_usdUserId = a}) + +-- | The client\'s current time in milliseconds since epoch. +usdCurrentTimeMillis :: Lens' UsersSessionsDelete (Maybe Int64) +usdCurrentTimeMillis + = lens _usdCurrentTimeMillis + (\ s a -> s{_usdCurrentTimeMillis = a}) + . mapping _Coerce + +-- | The ID of the session to be deleted. +usdSessionId :: Lens' UsersSessionsDelete Text +usdSessionId + = lens _usdSessionId (\ s a -> s{_usdSessionId = a}) + +instance GoogleRequest UsersSessionsDelete where + type Rs UsersSessionsDelete = () + requestClient UsersSessionsDelete{..} + = go _usdUserId _usdSessionId _usdCurrentTimeMillis + (Just AltJSON) + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersSessionsDeleteResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/Sessions/List.hs b/gen/Network/Google/Resource/Fitness/Users/Sessions/List.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/Sessions/List.hs @@ -0,0 +1,141 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.Sessions.List +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Lists sessions previously created. +-- +-- /See:/ for @fitness.users.sessions.list@. +module Network.Google.Resource.Fitness.Users.Sessions.List + ( + -- * REST Resource + UsersSessionsListResource + + -- * Creating a Request + , usersSessionsList + , UsersSessionsList + + -- * Request Lenses + , uslStartTime + , uslUserId + , uslEndTime + , uslPageToken + , uslIncludeDeleted + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.sessions.list@ method which the +-- 'UsersSessionsList' request conforms to. +type UsersSessionsListResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "sessions" :> + QueryParam "startTime" Text :> + QueryParam "endTime" Text :> + QueryParam "pageToken" Text :> + QueryParam "includeDeleted" Bool :> + QueryParam "alt" AltJSON :> + Get '[JSON] ListSessionsResponse + +-- | Lists sessions previously created. +-- +-- /See:/ 'usersSessionsList' smart constructor. +data UsersSessionsList = UsersSessionsList + { _uslStartTime :: !(Maybe Text) + , _uslUserId :: !Text + , _uslEndTime :: !(Maybe Text) + , _uslPageToken :: !(Maybe Text) + , _uslIncludeDeleted :: !(Maybe Bool) + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersSessionsList' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'uslStartTime' +-- +-- * 'uslUserId' +-- +-- * 'uslEndTime' +-- +-- * 'uslPageToken' +-- +-- * 'uslIncludeDeleted' +usersSessionsList + :: Text -- ^ 'uslUserId' + -> UsersSessionsList +usersSessionsList pUslUserId_ = + UsersSessionsList + { _uslStartTime = Nothing + , _uslUserId = pUslUserId_ + , _uslEndTime = Nothing + , _uslPageToken = Nothing + , _uslIncludeDeleted = Nothing + } + +-- | An RFC3339 timestamp. Only sessions ending between the start and end +-- times will be included in the response. +uslStartTime :: Lens' UsersSessionsList (Maybe Text) +uslStartTime + = lens _uslStartTime (\ s a -> s{_uslStartTime = a}) + +-- | List sessions for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +uslUserId :: Lens' UsersSessionsList Text +uslUserId + = lens _uslUserId (\ s a -> s{_uslUserId = a}) + +-- | An RFC3339 timestamp. Only sessions ending between the start and end +-- times will be included in the response. +uslEndTime :: Lens' UsersSessionsList (Maybe Text) +uslEndTime + = lens _uslEndTime (\ s a -> s{_uslEndTime = a}) + +-- | The continuation token, which is used to page through large result sets. +-- To get the next page of results, set this parameter to the value of +-- nextPageToken from the previous response. +uslPageToken :: Lens' UsersSessionsList (Maybe Text) +uslPageToken + = lens _uslPageToken (\ s a -> s{_uslPageToken = a}) + +-- | If true, deleted sessions will be returned. When set to true, sessions +-- returned in this response will only have an ID and will not have any +-- other fields. +uslIncludeDeleted :: Lens' UsersSessionsList (Maybe Bool) +uslIncludeDeleted + = lens _uslIncludeDeleted + (\ s a -> s{_uslIncludeDeleted = a}) + +instance GoogleRequest UsersSessionsList where + type Rs UsersSessionsList = ListSessionsResponse + requestClient UsersSessionsList{..} + = go _uslUserId _uslStartTime _uslEndTime + _uslPageToken + _uslIncludeDeleted + (Just AltJSON) + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersSessionsListResource) + mempty diff --git a/gen/Network/Google/Resource/Fitness/Users/Sessions/Update.hs b/gen/Network/Google/Resource/Fitness/Users/Sessions/Update.hs new file mode 100644 --- /dev/null +++ b/gen/Network/Google/Resource/Fitness/Users/Sessions/Update.hs @@ -0,0 +1,125 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + +{-# OPTIONS_GHC -fno-warn-duplicate-exports #-} +{-# OPTIONS_GHC -fno-warn-unused-binds #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} + +-- | +-- Module : Network.Google.Resource.Fitness.Users.Sessions.Update +-- Copyright : (c) 2015 Brendan Hay +-- License : Mozilla Public License, v. 2.0. +-- Maintainer : Brendan Hay +-- Stability : auto-generated +-- Portability : non-portable (GHC extensions) +-- +-- Updates or insert a given session. +-- +-- /See:/ for @fitness.users.sessions.update@. +module Network.Google.Resource.Fitness.Users.Sessions.Update + ( + -- * REST Resource + UsersSessionsUpdateResource + + -- * Creating a Request + , usersSessionsUpdate + , UsersSessionsUpdate + + -- * Request Lenses + , usuPayload + , usuUserId + , usuCurrentTimeMillis + , usuSessionId + ) where + +import Network.Google.Fitness.Types +import Network.Google.Prelude + +-- | A resource alias for @fitness.users.sessions.update@ method which the +-- 'UsersSessionsUpdate' request conforms to. +type UsersSessionsUpdateResource = + "fitness" :> + "v1" :> + "users" :> + Capture "userId" Text :> + "sessions" :> + Capture "sessionId" Text :> + QueryParam "currentTimeMillis" (Textual Int64) :> + QueryParam "alt" AltJSON :> + ReqBody '[JSON] Session :> Put '[JSON] Session + +-- | Updates or insert a given session. +-- +-- /See:/ 'usersSessionsUpdate' smart constructor. +data UsersSessionsUpdate = UsersSessionsUpdate + { _usuPayload :: !Session + , _usuUserId :: !Text + , _usuCurrentTimeMillis :: !(Maybe (Textual Int64)) + , _usuSessionId :: !Text + } deriving (Eq,Show,Data,Typeable,Generic) + +-- | Creates a value of 'UsersSessionsUpdate' with the minimum fields required to make a request. +-- +-- Use one of the following lenses to modify other fields as desired: +-- +-- * 'usuPayload' +-- +-- * 'usuUserId' +-- +-- * 'usuCurrentTimeMillis' +-- +-- * 'usuSessionId' +usersSessionsUpdate + :: Session -- ^ 'usuPayload' + -> Text -- ^ 'usuUserId' + -> Text -- ^ 'usuSessionId' + -> UsersSessionsUpdate +usersSessionsUpdate pUsuPayload_ pUsuUserId_ pUsuSessionId_ = + UsersSessionsUpdate + { _usuPayload = pUsuPayload_ + , _usuUserId = pUsuUserId_ + , _usuCurrentTimeMillis = Nothing + , _usuSessionId = pUsuSessionId_ + } + +-- | Multipart request metadata. +usuPayload :: Lens' UsersSessionsUpdate Session +usuPayload + = lens _usuPayload (\ s a -> s{_usuPayload = a}) + +-- | Create sessions for the person identified. Use me to indicate the +-- authenticated user. Only me is supported at this time. +usuUserId :: Lens' UsersSessionsUpdate Text +usuUserId + = lens _usuUserId (\ s a -> s{_usuUserId = a}) + +-- | The client\'s current time in milliseconds since epoch. +usuCurrentTimeMillis :: Lens' UsersSessionsUpdate (Maybe Int64) +usuCurrentTimeMillis + = lens _usuCurrentTimeMillis + (\ s a -> s{_usuCurrentTimeMillis = a}) + . mapping _Coerce + +-- | The ID of the session to be created. +usuSessionId :: Lens' UsersSessionsUpdate Text +usuSessionId + = lens _usuSessionId (\ s a -> s{_usuSessionId = a}) + +instance GoogleRequest UsersSessionsUpdate where + type Rs UsersSessionsUpdate = Session + requestClient UsersSessionsUpdate{..} + = go _usuUserId _usuSessionId _usuCurrentTimeMillis + (Just AltJSON) + _usuPayload + fitnessService + where go + = buildClient + (Proxy :: Proxy UsersSessionsUpdateResource) + mempty diff --git a/gogol-fitness.cabal b/gogol-fitness.cabal new file mode 100644 --- /dev/null +++ b/gogol-fitness.cabal @@ -0,0 +1,58 @@ +name: gogol-fitness +version: 0.0.1 +synopsis: Google Fitness SDK. +homepage: https://github.com/brendanhay/gogol +bug-reports: https://github.com/brendanhay/gogol/issues +license: OtherLicense +license-file: LICENSE +author: Brendan Hay +maintainer: Brendan Hay +copyright: Copyright (c) 2015 Brendan Hay +category: Network, Google, Cloud +build-type: Simple +cabal-version: >= 1.10 +extra-source-files: README.md + +description: + Google Fit API + . + /Warning:/ This is an experimental prototype/preview release which is still + under exploratory development and not intended for public use, caveat emptor! + . + This library is compatible with version @v1@ + of the API. + +source-repository head + type: git + location: git://github.com/brendanhay/gogol.git + +library + default-language: Haskell2010 + hs-source-dirs: src gen + + ghc-options: -Wall + + exposed-modules: + Network.Google.Fitness + , Network.Google.Fitness.Types + , Network.Google.Resource.Fitness.Users.DataSet.Aggregate + , Network.Google.Resource.Fitness.Users.DataSources.Create + , Network.Google.Resource.Fitness.Users.DataSources.DataSets.Delete + , Network.Google.Resource.Fitness.Users.DataSources.DataSets.Get + , Network.Google.Resource.Fitness.Users.DataSources.DataSets.Patch + , Network.Google.Resource.Fitness.Users.DataSources.Delete + , Network.Google.Resource.Fitness.Users.DataSources.Get + , Network.Google.Resource.Fitness.Users.DataSources.List + , Network.Google.Resource.Fitness.Users.DataSources.Patch + , Network.Google.Resource.Fitness.Users.DataSources.Update + , Network.Google.Resource.Fitness.Users.Sessions.Delete + , Network.Google.Resource.Fitness.Users.Sessions.List + , Network.Google.Resource.Fitness.Users.Sessions.Update + + other-modules: + Network.Google.Fitness.Types.Product + , Network.Google.Fitness.Types.Sum + + build-depends: + gogol-core == 0.0.1.* + , base >= 4.7 && < 5