1203 lines
37 KiB
Dart
1203 lines
37 KiB
Dart
import 'package:dio/dio.dart';
|
|
import 'package:ftc_mobile_app/ftc_mobile_app.dart';
|
|
import 'package:ftc_mobile_app/models/clients/PBSPlanModel.dart';
|
|
import 'package:ftc_mobile_app/models/clients/allCareNotes/AllCareNotesListResponse.dart';
|
|
import 'package:ftc_mobile_app/models/clients/allCareNotes/CareNoteData.dart';
|
|
import 'package:ftc_mobile_app/models/clients/body_points_category.dart';
|
|
import 'package:ftc_mobile_app/models/clients/consent_details_model.dart';
|
|
import 'package:ftc_mobile_app/models/clients/memoryListResponse/MemoryListResponse.dart';
|
|
import 'package:ftc_mobile_app/models/clients/memoryListResponse/MemoryListResponseData.dart';
|
|
import 'package:ftc_mobile_app/models/clients/recent_incidents_model.dart';
|
|
import 'package:ftc_mobile_app/models/clients/add_pbs_plan_model.dart';
|
|
import 'package:ftc_mobile_app/models/clients/riskAssessmentResponse/GetRiskAssessmentResponse.dart';
|
|
import 'package:ftc_mobile_app/models/clients/riskAssessmentResponse/RiskAssessmentData.dart';
|
|
import 'package:ftc_mobile_app/utilities/extensions/custom_extensions.dart';
|
|
import '../models/appointmentsListResponse/AppointmentsListResponse.dart';
|
|
import '../models/clients/HealthIssuesDetailsModel.dart';
|
|
import '../models/clients/allClientsList/AllClientsResponse.dart';
|
|
import '../models/clients/documents_list_model.dart';
|
|
import '../models/create_care_plan_request.dart';
|
|
import '../models/profile_screen_model.dart';
|
|
|
|
class ClientService {
|
|
static final ClientService _instance = ClientService._private();
|
|
|
|
ClientService._private();
|
|
|
|
factory ClientService() {
|
|
return _instance;
|
|
}
|
|
|
|
final HttpRequestClient _httpClient = HttpRequestClient();
|
|
|
|
Future<dynamic> getUserDetails() async {
|
|
// String userJson = LocalStorageManager.getSessionToken(
|
|
// tokenKey: LocalStorageKeys.kUserModelKey,
|
|
// );
|
|
// UserModel userModel = UserModel.fromJson(json.decode(userJson));
|
|
Map<String, dynamic> requestBody = {
|
|
"sortproperty": "createdAt",
|
|
"sortorder": -1,
|
|
"offset": 0,
|
|
"limit": 1,
|
|
"query": {
|
|
"critarion": {
|
|
"active": true,
|
|
"_id": LocalStorageManager.userId,
|
|
},
|
|
"addedby": "_id email name",
|
|
"lastModifiedBy": "_id email name"
|
|
},
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.userProfileUrl,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("success")) {
|
|
final profileDataModel = ProfileDataModel.fromJson({
|
|
'status': "${responseModel.statusCode}",
|
|
"data": responseModel.data,
|
|
'message': responseModel.statusDescription,
|
|
});
|
|
// await LocalStorageManager.saveSession(
|
|
// tokenKey: LocalStorageKeys.kProfileModelKey,
|
|
// tokenValue: json.encode(profileDataModel.toJson()),
|
|
// );
|
|
return profileDataModel;
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
}
|
|
|
|
Future<dynamic> addConsentDetails(
|
|
{required String description, required String staffId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"staffId": staffId,
|
|
"active": true,
|
|
"description": description,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.addConsentUrl,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription
|
|
.contains("Consent Template added successfully")) {
|
|
if (responseModel.data is List && responseModel.data.length > 0) {
|
|
ConsentDetailsModel consentDetailsModel =
|
|
ConsentDetailsModel.fromJson(responseModel.data[0]);
|
|
return consentDetailsModel;
|
|
} else {
|
|
ConsentDetailsModel consentDetailsModel =
|
|
ConsentDetailsModel.fromJson(responseModel.data);
|
|
return consentDetailsModel;
|
|
}
|
|
// return true;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> getConsentDetails({required String staffId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"sortproperty": "createdAt",
|
|
"sortorder": -1,
|
|
"staffId": staffId,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getConsentListUrl,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("success")) {
|
|
List<ConsentDetailsModel> consentList = [];
|
|
if (responseModel.data is List) {
|
|
for (var singleEntry in responseModel.data) {
|
|
consentList.add(ConsentDetailsModel.fromJson(singleEntry));
|
|
}
|
|
} else {}
|
|
return consentList;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> deleteConsent({required String consentId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"templateId": consentId,
|
|
};
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.deleteConsentUrl,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase() ==
|
|
"template removed successfully") {
|
|
return true;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> updateConsentDetails(
|
|
{required String description, required String consentId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"templateId": consentId,
|
|
"description": description,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.updateConsentUrl,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription == "Updated successfully") {
|
|
return true;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<AllClientsResponse> getServiceUsersList({
|
|
String searchText = "",
|
|
int limit = 20,
|
|
int offset = 0,
|
|
}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"sortproperty": "createdAt",
|
|
"sortorder": -1,
|
|
"offset": offset,
|
|
"limit": limit,
|
|
"searchText": searchText,
|
|
"query": {
|
|
"critarion": {"role": "serviceuser"}
|
|
}
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getServiceUsersListUrl,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("success")) {
|
|
final resp = AllClientsResponseData.fromJson(responseModel.data);
|
|
|
|
// List<ServiceUserModel> serviceUsers = [];
|
|
// for (var singleUser in responseModel.data['serviceUsers']) {
|
|
// serviceUsers.add(ServiceUserModel.fromJson(singleUser));
|
|
// }
|
|
return AllClientsResponse(success: true, data: resp);
|
|
} else {
|
|
return AllClientsResponse(
|
|
success: false,
|
|
message: responseModel.statusDescription,
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<AllClientsResponse> getAllUsersList({
|
|
String searchText = "",
|
|
int limit = 20,
|
|
int offset = 0,
|
|
}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"sortproperty": "createdAt",
|
|
"sortorder": -1,
|
|
"offset": 0,
|
|
"query": {
|
|
"critarion": {"active": true, "role": "staffmember"}
|
|
}
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.listAllUsers,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("success")) {
|
|
final resp = AllClientsResponseData.fromJson(responseModel.data);
|
|
|
|
// List<ServiceUserModel> serviceUsers = [];
|
|
// for (var singleUser in responseModel.data['serviceUsers']) {
|
|
// serviceUsers.add(ServiceUserModel.fromJson(singleUser));
|
|
// }
|
|
return AllClientsResponse(success: true, data: resp);
|
|
} else {
|
|
return AllClientsResponse(
|
|
success: false,
|
|
message: responseModel.statusDescription,
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<dynamic> getBodyPointsCategoryList() async {
|
|
Map<String, dynamic> requestBody = {};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getBodyPointsCategoryListURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription
|
|
.toLowerCase()
|
|
.contains("category list")) {
|
|
List<BodyPointsCategory> bodyPointsCategoryList = [];
|
|
for (var singleUser in responseModel.data) {
|
|
bodyPointsCategoryList.add(BodyPointsCategory.fromJson(singleUser));
|
|
}
|
|
return bodyPointsCategoryList;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> addHealthIssue({
|
|
required String userId,
|
|
required String category,
|
|
required String healthNote,
|
|
required String complaint,
|
|
}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"userId": userId,
|
|
"category": category,
|
|
"healthNote": healthNote,
|
|
"complaint": complaint,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.addHealthIssuesURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
return HealthIssueDetailsModel.fromJson(responseModel.data);
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
}
|
|
|
|
Future<dynamic> getHealthIssues({required String userId}) async {
|
|
// String userJson = _sessionManagement.getSessionToken(
|
|
// tokenKey: SessionKeys.kUserModelKey,
|
|
// );
|
|
// UserModel userModel = UserModel.fromJson(json.decode(userJson));
|
|
|
|
Map<String, dynamic> requestBody = {
|
|
"userId": userId,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getHealthIssuesListURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription
|
|
.toLowerCase()
|
|
.contains("health issues list")) {
|
|
List<HealthIssueDetailsModel> healthIssuesDetailsList = [];
|
|
for (var singleHealthIssue in responseModel.data) {
|
|
healthIssuesDetailsList
|
|
.add(HealthIssueDetailsModel.fromJson(singleHealthIssue));
|
|
}
|
|
return healthIssuesDetailsList;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> updateHealthIssueData({
|
|
required String issueId,
|
|
required String categoryId,
|
|
bool? status,
|
|
String? complaint,
|
|
String? healthNote,
|
|
}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"issueId": issueId,
|
|
"category": categoryId,
|
|
};
|
|
|
|
if (status != null) {
|
|
requestBody['status'] = status;
|
|
}
|
|
|
|
if (complaint.isNotNullOrEmpty()) {
|
|
requestBody['complaint'] = complaint;
|
|
}
|
|
|
|
if (healthNote.isNotNullOrEmpty()) {
|
|
requestBody['healthNote'] = healthNote;
|
|
}
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.updateHealthIssueURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
return BodyPointsCategory.fromJson(responseModel.data);
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
}
|
|
|
|
Future<dynamic> healthIssueChildCategory({required String categoryId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"categoryId": categoryId,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getHealthIssueChildCategoryListURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("success")) {
|
|
List<SubCat> subCatList = [];
|
|
for (var singleSubCat in responseModel.data) {
|
|
subCatList.add(SubCat.fromJson(singleSubCat));
|
|
}
|
|
return subCatList;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> addRecentIncidentService(
|
|
{required String userId,
|
|
required String incidentTitle,
|
|
required String note,
|
|
required int incidentDate}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"userId": userId,
|
|
"note": note,
|
|
"incidentTitle": incidentTitle,
|
|
"incidentDate": incidentDate,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.addRecentIncidentServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("success")) {
|
|
RecentIncidentsModel recentIncidentsModel =
|
|
RecentIncidentsModel.fromJson(responseModel.data);
|
|
return recentIncidentsModel;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> getRecentIncidentsListService(
|
|
{required String userId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"query": {
|
|
"critarion": {
|
|
"userId": userId,
|
|
"active": true,
|
|
},
|
|
},
|
|
"sortProperty": "createdAt",
|
|
"sortOrder": -1,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getRecentIncidentsListServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("success")) {
|
|
List<RecentIncidentsModel> recentIncidentsModelList = [];
|
|
if (responseModel.data is List) {
|
|
for (var data in responseModel.data) {
|
|
recentIncidentsModelList.add(RecentIncidentsModel.fromJson(data));
|
|
}
|
|
return recentIncidentsModelList;
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> updateRecentIncidentService({
|
|
required String incidentId,
|
|
required String incidentTitle,
|
|
required String incidentNote,
|
|
required int incidentDate,
|
|
}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"id": incidentId,
|
|
"incidentDate": incidentDate,
|
|
"incidentTitle": incidentTitle,
|
|
"note": incidentNote,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.updateRecentIncidentServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("success")) {
|
|
if (responseModel.data is Map<String, dynamic>) {
|
|
return RecentIncidentsModel.fromJson(responseModel.data);
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> deleteRecentIncident({required String incidentId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"id": incidentId,
|
|
};
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.deleteRecentIncidentUrl,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("success")) {
|
|
if (responseModel.data is Map<String, dynamic>) {
|
|
return RecentIncidentsModel.fromJson(responseModel.data);
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> addPbsPlanService(
|
|
{required String userId,
|
|
required String staffId,
|
|
required String postIncidentSupport,
|
|
required String reactiveStartegies,
|
|
required String secondaryPrevention,
|
|
required String managementOfBehaviorPlan,
|
|
required String aboutPlan}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"userId": userId,
|
|
"staffId": staffId,
|
|
"postIncidentSupport": postIncidentSupport,
|
|
"reactiveStartegies": reactiveStartegies,
|
|
"secondaryPrevention": secondaryPrevention,
|
|
"managementOfBehaviorPlan": managementOfBehaviorPlan,
|
|
"aboutPlan": aboutPlan,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.addPbsPlanServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("added")) {
|
|
print(
|
|
'---------data is not null returning PBSListDataJson model from service');
|
|
AddPBSPlanModel addPBSPlanModel =
|
|
AddPBSPlanModel.fromJson(responseModel.data);
|
|
return addPBSPlanModel;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> updatePbsPlanService(
|
|
{required String id,
|
|
required String userId,
|
|
required String staffId,
|
|
required String postIncidentSupport,
|
|
required String reactiveStartegies,
|
|
required String secondaryPrevention,
|
|
required String managementOfBehaviorPlan,
|
|
required String aboutPlan}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"userId": userId,
|
|
"staffId": staffId,
|
|
"postIncidentSupport": postIncidentSupport,
|
|
"reactiveStartegies": reactiveStartegies,
|
|
"secondaryPrevention": secondaryPrevention,
|
|
"managementOfBehaviorPlan": managementOfBehaviorPlan,
|
|
"aboutPlan": aboutPlan,
|
|
"id": id,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.updatePbsPlanServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription
|
|
.toLowerCase()
|
|
.contains("pbsplan updated")) {
|
|
return AddPBSPlanModel.fromJson(responseModel.data);
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> getPbsPlanListService({required String userId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"query": {
|
|
"critarion": {"userId": userId}
|
|
},
|
|
"sortProperty": "createdAt",
|
|
"sortOrder": -1
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getPbsPlanServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription
|
|
.toLowerCase()
|
|
.contains("pbs plan list")) {
|
|
PBSListDataJson pbsDataJsonModel = PBSListDataJson.empty();
|
|
if (responseModel.data != null) {
|
|
pbsDataJsonModel = PBSListDataJson.fromJson(responseModel.data);
|
|
return pbsDataJsonModel;
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> deletePbsPlanService({required String pbsId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"pbsId": pbsId,
|
|
};
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.deletePbsPlanServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription.toLowerCase().contains("deleted")) {
|
|
return true;
|
|
// if(responseModel.data is Map<String,dynamic>){
|
|
// return RecentIncidentsModel.fromJson(responseModel.data);
|
|
// }
|
|
// else{
|
|
// return responseModel.statusDescription;
|
|
// }
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> getDocumentListService(
|
|
{required String serviceUserId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"sortProperty": "createdAt",
|
|
"sortOrder": -1,
|
|
// "offset": 0,
|
|
// "limit": 10,
|
|
"query": {
|
|
"critarion": {"userId": serviceUserId}
|
|
}
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getDocumentsListServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription
|
|
.toLowerCase()
|
|
.contains("document list")) {
|
|
if (responseModel.data != null) {
|
|
return DocumentsListModel.fromJson(responseModel.data);
|
|
} else {
|
|
return DocumentsListModel.empty();
|
|
}
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
}
|
|
|
|
Future<dynamic> addDocumentService({
|
|
required String userId,
|
|
required String docPath,
|
|
required String docDetails,
|
|
required String title,
|
|
required String addedBy,
|
|
}) async {
|
|
if (docPath.isEmpty) {
|
|
return "Please select document file first";
|
|
}
|
|
|
|
final resp = await uploadDocumentService(docPath: docPath);
|
|
|
|
if (resp is! String) {
|
|
return;
|
|
}
|
|
|
|
Map<String, dynamic> requestBody = {
|
|
"userId": userId,
|
|
"docPath": resp,
|
|
"details": docDetails,
|
|
"title": title,
|
|
"addedBy": addedBy,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.addDocumentServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
(responseModel.statusDescription
|
|
.toLowerCase()
|
|
.contains("dcoument added") ||
|
|
responseModel.statusDescription
|
|
.toLowerCase()
|
|
.contains("document added"))) {
|
|
print(
|
|
'---------data is not null returning Dcoument Added model from service');
|
|
DocumentModel documentModel = DocumentModel.fromJson(responseModel.data);
|
|
return documentModel;
|
|
} else {
|
|
responseModel.statusDescription;
|
|
}
|
|
}
|
|
|
|
Future<dynamic> updateDocumentService({
|
|
required String userId,
|
|
required String docId,
|
|
required String docPath,
|
|
required String docDetails,
|
|
required String title,
|
|
required String addedBy,
|
|
}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"userId": userId,
|
|
"documentId": docId,
|
|
"docPath": docPath,
|
|
"details": docDetails,
|
|
"title": title,
|
|
"addedBy": addedBy,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.updateDocumentServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
return DocumentModel.fromJson(responseModel.data);
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
}
|
|
|
|
Future<dynamic> deleteDocumentService({required String docId}) async {
|
|
Map<String, dynamic> requestBody = {
|
|
"documentId": docId,
|
|
};
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.deleteDocServiceURL,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 &&
|
|
responseModel.statusCode <= 230 &&
|
|
responseModel.statusDescription
|
|
.toLowerCase()
|
|
.contains("document removed successfully")) {
|
|
if (responseModel.data['deletedCount'] == 0) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> uploadDocumentService({
|
|
required String docPath,
|
|
}) async {
|
|
final files = <String, String>{"attachements": docPath};
|
|
ResponseModel responseModel = await _httpClient.postMultipartRequest(
|
|
files: files,
|
|
url: WebUrls.uploadDocServiceURL,
|
|
);
|
|
|
|
if (responseModel.statusDescription
|
|
.toLowerCase()
|
|
.contains("file uploaded successfully")) {
|
|
return responseModel.data[0]
|
|
["fileNameInDirectory"]; // returning file path from response
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> createCarePlan({
|
|
required CreateCarePlanRequest request,
|
|
}) async {
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.createCarePlanURL,
|
|
requestBody: request.toJson(),
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
return responseModel;
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
Future<dynamic> getCarePlansList(
|
|
{required String serviceUserId, int limit = 20, int offset = 0}) async {
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getCarePlansListURL,
|
|
requestBody: {
|
|
"query": {
|
|
"critarion": {
|
|
"userId": serviceUserId,
|
|
"active": true
|
|
}
|
|
},
|
|
"sortproperty": "eventDateTime",
|
|
"sortorder": -1,
|
|
"limit": limit,
|
|
"offset": offset
|
|
},
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
print("getCarePlansList responseModel: ${responseModel.toJson()}");
|
|
return AllCareNotesListResponse.success()
|
|
..message = responseModel.statusDescription
|
|
..data = CareNoteData.fromJson(responseModel.data);
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
}
|
|
|
|
Future<AppointmentsListResponse> getAppointmentsList(
|
|
{required String serviceId,
|
|
required int startDate,
|
|
required int endDate}) async {
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getAppointmentsByDate,
|
|
requestBody: {
|
|
"userId": serviceId,
|
|
"startDate": startDate,
|
|
"endDate": endDate,
|
|
},
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
if (responseModel.data is List &&
|
|
(responseModel.data as List).isNotNullOrEmpty()) {
|
|
return AppointmentsListResponse(
|
|
success: true,
|
|
data: (responseModel.data as List)
|
|
.map((e) => AppointmentsListResponseData.fromJson(e))
|
|
.toList());
|
|
}
|
|
|
|
return AppointmentsListResponse(success: true, data: []);
|
|
// print("getCarePlansList responseModel: ${responseModel.toJson()}");
|
|
// return AllCareNotesListResponse.success()
|
|
// ..message = responseModel.statusDescription
|
|
// ..data = CareNoteData.fromJson(responseModel.data);
|
|
} else {
|
|
return AppointmentsListResponse(
|
|
success: false, message: responseModel.statusDescription);
|
|
}
|
|
}
|
|
|
|
Future<GetRiskAssessmentResponse> getRiskAssessments(
|
|
{required String serviceUserId}) async {
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getRiskAssesments,
|
|
requestBody: {"userId": serviceUserId},
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
if (responseModel.data is List &&
|
|
(responseModel.data as List).isNotNullOrEmpty()) {
|
|
return GetRiskAssessmentResponse(
|
|
success: true,
|
|
data: (responseModel.data as List)
|
|
.map((e) => RiskAssessmentData.fromJson(e))
|
|
.toList());
|
|
}
|
|
|
|
return GetRiskAssessmentResponse(success: true, data: []);
|
|
} else {
|
|
return GetRiskAssessmentResponse(
|
|
success: false, message: responseModel.statusDescription);
|
|
}
|
|
}
|
|
|
|
Future<MemoryListResponse> getMemoryList(
|
|
{required String serviceUserId}) async {
|
|
final req = {
|
|
"query": {
|
|
"critarion": {"userId": serviceUserId}
|
|
},
|
|
"sortproperty": "createdAt",
|
|
"sortorder": -1
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.getMemoryList,
|
|
requestBody: req,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
if (responseModel.data is Map) {
|
|
return MemoryListResponse(
|
|
success: true,
|
|
data: MemoryListResponseData.fromJson(responseModel.data));
|
|
}
|
|
|
|
return MemoryListResponse(success: false);
|
|
} else {
|
|
return MemoryListResponse(
|
|
success: false, message: responseModel.statusDescription);
|
|
}
|
|
}
|
|
|
|
Future<dynamic> createRiskAssesments(
|
|
{required RiskAssessmentData data}) async {
|
|
final req = {
|
|
"userId": data.userId,
|
|
"hazard": data.hazard,
|
|
"personsExposedToHazard": data.personsExposedToHazard,
|
|
"riskIdentified": data.riskIdentified,
|
|
"coldMeasureRequired": data.coldMeasureRequired,
|
|
"pureRiskRating": {
|
|
"c": data.pureRiskRating?.c ?? 1,
|
|
"l": "${data.pureRiskRating?.l ?? 1}",
|
|
"r": "${data.pureRiskRating?.r ?? 1}",
|
|
},
|
|
"inPlace": {
|
|
"y": "${data.inPlace?.y ?? 1}",
|
|
"n": "${data.inPlace?.n ?? 1}",
|
|
},
|
|
"residualRiskRating": {
|
|
"c": "${data.residualRiskRating?.c ?? 1}",
|
|
"l": "${data.residualRiskRating?.l ?? 1}",
|
|
"r": "${data.residualRiskRating?.r ?? 1}",
|
|
}
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.createRiskAssesments,
|
|
requestBody: req,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
|
|
if ((responseModel.statusCode ~/ 100) == 2) {
|
|
return true;
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
}
|
|
|
|
Future<dynamic> uploadMemoryBoxFile({
|
|
required String filePath,
|
|
}) async {
|
|
final formData = FormData();
|
|
formData.files.add(MapEntry(
|
|
"file",
|
|
MultipartFile.fromFileSync(filePath),
|
|
));
|
|
|
|
ResponseModel responseModel = await _httpClient.safeFormDataRequest(
|
|
url: WebUrls.uploadMemoryBoxFile,
|
|
body: formData,
|
|
);
|
|
|
|
print("responseModel is : ${responseModel.toJson()}");
|
|
|
|
if ((responseModel.statusCode ~/ 100) == 2) {
|
|
//Success response
|
|
return responseModel.data; // returning file path from response
|
|
} else {
|
|
return {
|
|
"message": responseModel.statusDescription,
|
|
};
|
|
}
|
|
}
|
|
|
|
//return true if success else error message string
|
|
Future<dynamic> addMemoryBoxFile({
|
|
required String userId,
|
|
required String filePath,
|
|
required String noteDetails,
|
|
}) async {
|
|
if (filePath.isEmpty) {
|
|
return "Please select file first";
|
|
}
|
|
|
|
final resp = await uploadMemoryBoxFile(filePath: filePath);
|
|
if (resp is Map) {
|
|
return resp['message'];
|
|
}
|
|
|
|
// String userJson = LocalStorageManager.getSessionToken(
|
|
// tokenKey: LocalStorageKeys.kUserModelKey,
|
|
// );
|
|
// UserModel userModel = UserModel.fromJson(json.decode(userJson));
|
|
|
|
Map<String, dynamic> requestBody = {
|
|
"addedBy": LocalStorageManager.userId,
|
|
"userId": userId,
|
|
"filePath": resp,
|
|
"note": noteDetails,
|
|
};
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.addMemoryBox,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
// DocumentModel documentModel = DocumentModel.fromJson(responseModel.data);
|
|
return true;
|
|
} else {
|
|
responseModel.statusDescription;
|
|
}
|
|
}
|
|
|
|
Future<dynamic> updateMemoryBoxFile({
|
|
required String userId,
|
|
required String id,
|
|
required String filePath,
|
|
required String noteDetails,
|
|
}) async {
|
|
dynamic resp;
|
|
|
|
if (filePath.isNotEmpty) {
|
|
//upload file
|
|
resp = await uploadMemoryBoxFile(filePath: filePath);
|
|
|
|
// On error
|
|
if (resp is Map) {
|
|
return resp['message'];
|
|
}
|
|
}
|
|
|
|
// String userJson = LocalStorageManager.getSessionToken(
|
|
// tokenKey: LocalStorageKeys.kUserModelKey,
|
|
// );
|
|
// UserModel userModel = UserModel.fromJson(json.decode(userJson));
|
|
|
|
Map<String, dynamic> requestBody = {
|
|
"addedBy": LocalStorageManager.userId,
|
|
"userId": userId,
|
|
"memoryBoxId": id,
|
|
};
|
|
|
|
if (resp is String) {
|
|
requestBody['filePath'] = resp;
|
|
}
|
|
|
|
if (noteDetails.isNotEmpty) {
|
|
requestBody['note'] = noteDetails;
|
|
}
|
|
|
|
ResponseModel responseModel = await _httpClient.customRequest(
|
|
"POST",
|
|
url: WebUrls.updateMemoryBox,
|
|
requestBody: requestBody,
|
|
requestHeader: {'Content-Type': 'application/json'},
|
|
isBearerHeaderRequired: true,
|
|
isBearer: true,
|
|
);
|
|
if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
|
|
// return DocumentModel.fromJson(responseModel.data);
|
|
return true;
|
|
} else {
|
|
return responseModel.statusDescription;
|
|
}
|
|
}
|
|
}
|