function AdminTagService(bip) {
    this.bip = bip;
}

AdminTagService.prototype.all = function () {
    return this.bip.get('/api/AdminTags');
};

AdminTagService.prototype.create = function (adminTag) {
    return this.bip.post('/api/AdminTags', adminTag);
};

AdminTagService.prototype.delete = function (adminTagId) {
    return this.bip.delete('/api/AdminTags/' + adminTagId);
};

AdminTagService.prototype.get = function (adminTagId) {
    return this.bip.get('/api/AdminTags/' + adminTagId);
};

AdminTagService.prototype.update = function (adminTagId, adminTag) {
    return this.bip.put('/api/AdminTags/' + adminTagId, adminTag);
};
function AssetInputConfigurationService(bip) {
    this.bip = bip;
};

AssetInputConfigurationService.prototype.get = function (id) {
    return this.bip.get('/api/AssetInputConfigurations/' + id);
};

AssetInputConfigurationService.prototype.create = function (assetInputConfiguration) {
    return this.bip.post('/api/AssetInputConfigurations/', assetInputConfiguration);
};

AssetInputConfigurationService.prototype.update = function (id, assetInputConfiguration) {
    return this.bip.put('/api/AssetInputConfigurations/' + id, assetInputConfiguration);
};

AssetInputConfigurationService.prototype.all = function () {
    return this.bip.get('/api/AssetInputConfigurations/');
};

AssetInputConfigurationService.prototype.delete = function (id) {
    return this.bip.delete('/api/AssetInputConfigurations/' + id);
};

AssetInputConfigurationService.prototype.tags = function () {
    return this.bip.get('/api/AssetInputConfigurations/tags');
};

function AuditEntryService(bip) {
    this.bip = bip;
}

AuditEntryService.prototype.getForTableAndResource = function (table, resourceId) {
    return this.bip.get('/api/AuditEntries/Table/' + table + '/Resource/' + resourceId).then(function (apiEntries) {
        apiEntries.forEach(function (apiEntry) {
            apiEntry.TimeStamp = new Date(apiEntry.TimeStamp);
        });
        return apiEntries;
    });
};

AuditEntryService.prototype.getForSettings = function () {
    return this.bip.get('/api/AuditEntries/ListForSettings').then(function (apiEntries) {
        apiEntries.forEach(function (apiEntry) {
            apiEntry.TimeStamp = new Date(apiEntry.TimeStamp);
        });
        return apiEntries;
    });
};
function BlobService(bip) {
    this.bip = bip;
}

BlobService.prototype.all = function () {
    return this.bip.get('/api/Blobs');
};

BlobService.prototype.upload = function (blob, name) {
    var data = new FormData();
    data.append('file', blob, name);
    return this.bip.upload('/api/Blobs/', data).then(function (ids) { return ids[0]; });
};

BlobService.prototype.download = function (blobId) {
    return this.bip.download('/api/Blobs/' + blobId);
};

BlobService.prototype.getMetadata = function (blobId) {
    return this.bip.get('/api/Blobs/' + blobId + '/Metadata');
};

BlobService.prototype.delete = function (blobId) {
    return this.bip.delete('/api/Blobs/' + blobId);
};
function BlobStorageAccessService(bip) {
    this.bip = bip;
}

BlobStorageAccessService.prototype.getHelpKey = function () {
    return this.bip.get('/api/BlobStorageAccess/helpvideos/key');
};
BlobStorageAccessService.prototype.getArticleKey = function () {
    return this.bip.get('/api/BlobStorageAccess/articlemedia/key');
};
BlobStorageAccessService.prototype.getNewsletterKey = function () {
    return this.bip.get('/api/BlobStorageAccess/newsletters/key');
};

function ContractMappingService(bip) {
    this.bip = bip;
}

ContractMappingService.prototype.all = function (contractId) {
    return this.bip.get('/api/ContractMapping');
};

ContractMappingService.prototype.getFromContractId = function (contractId) {
    return this.bip.get('/api/Contracts/' + contractId + '/LookupColumn');
};

ContractMappingService.prototype.getFromLookUpId = function (lookupColumnId) {
    return this.bip.get('/api/LookupColumns/' + lookupColumnId + '/Contract');
};

ContractMappingService.prototype.delete = function (contractId, lookupColumnId) {
    return this.bip.delete('/api/Contracts/' + contractId + '/LookupColumn/' + lookupColumnId);
};

ContractMappingService.prototype.createOrUpdate = function (contractMapping) {
    return this.bip.put('/api/Contracts/' + contractMapping.ContractID + '/LookupColumn/' + contractMapping.LookupColumnID + '/' + contractMapping.ContractColumnID);
};


function ContractService(bip) {
    this.bip = bip;
}

ContractService.prototype.all = function () {
    return this.bip.get('/api/Contracts');
};

ContractService.prototype.get = function (contractId) {
    return this.bip.get('/api/Contracts/' + contractId);
};

ContractService.prototype.create = function (contract) {
    return this.bip.post('/api/Contracts', contract);
};

ContractService.prototype.delete = function (contractId) {
    return this.bip.delete('/api/Contracts/' + contractId);
};

ContractService.prototype.update = function (contractId, contract) {
    return this.bip.put('/api/Contracts/' + contractId, contract);
};


function ContractValueService(bip) {
    this.bip = bip;
}

ContractValueService.prototype.all = function () {
    return this.bip.get('/api/ContractValues');
};

ContractValueService.prototype.getSystemValueIds = function (contractId) {
    return this.bip.get('/api/Contracts/' + contractId + '/SystemValue');
};

ContractValueService.prototype.getByContractId = function (contractId) {
    return this.bip.get('/api/Contracts/' + contractId + '/ContractValues');
};

ContractValueService.prototype.getContractIds = function (systemValueId) {
    return this.bip.get('/api/SystemValues/' + systemValueId + '/Contract');
};

ContractValueService.prototype.create = function (contractValue) {
    return this.bip.post('/api/ContractValues', contractValue);
};

ContractValueService.prototype.delete = function (id) {
    return this.bip.delete('/api/ContractValues/' + id);
};

ContractValueService.prototype.update = function (contractValue, clearHistory) {
    return this.bip.put('/api/ContractValues/' + (contractValue.id || contractValue.ID) + (clearHistory ? '?clearHistory=true' : ''), contractValue);
};


function DebugService(bip) {
    this.bip = bip;
};

DebugService.prototype.get = function () {
    return this.bip.get('/api/Debug');
};

DebugService.prototype.set = function (value) {
    return this.bip.post('/api/Debug', value);
};
function DispatchDurationService(bip) {
    this.bip = bip;
}


DispatchDurationService.prototype.create = function (dispatchDuration) {
    return this.bip.post('/api/DispatchDurations', dispatchDuration);
};

DispatchDurationService.prototype.delete = function (database, contractId, dispatchId) {
    return this.bip.delete('/api/DispatchDurations/' + database + '/' + contractId + '/' + dispatchId);
};

function DivisionService(bip) {
    this.bip = bip;
}

DivisionService.prototype.all = function () {
    return this.bip.get('/api/Divisions');
};

DivisionService.prototype.create = function (division) {
    return this.bip.post('/api/Divisions', division);
};

DivisionService.prototype.delete = function (divisionId) {
    return this.bip.delete('/api/Divisions/' + divisionId);
};

DivisionService.prototype.get = function (divisionId) {
    return this.bip.get('/api/Divisions/' + divisionId);
};

DivisionService.prototype.update = function (divisionId, division) {
    return this.bip.put('/api/Divisions/' + divisionId, division);
};

DivisionService.prototype.tags = function () {
    return this.bip.get('/api/Divisions/tags');
};
function EmailDomainService(bip) {
    this.bip = bip;
}

EmailDomainService.prototype.all = function () {
    return this.bip.get('/api/EmailDomain');
};

EmailDomainService.prototype.create = function (domainName) {
    return this.bip.post('/api/EmailDomain/', domainName);
};

EmailDomainService.prototype.delete = function (domainId) {
    return this.bip.delete('/api/EmailDomain/' + domainId);
};

EmailDomainService.prototype.get = function (domainId) {
    return this.bip.get('/api/EmailDomain/' + domainId);
};

EmailDomainService.prototype.update = function (domainId, domainName) {
    return this.bip.put('/api/EmailDomain/' + domainId, domainName);
};
function EmailEventHeaderService(bip) {
    this.bip = bip;
}

EmailEventHeaderService.prototype.all = function () {
    return this.bip.get('/api/EmailEventHeaders');
};

EmailEventHeaderService.prototype.get = function (emailEventHeaderId) {
    return this.bip.get('/api/EmailEventHeaders/' + emailEventHeaderId);
};

EmailEventHeaderService.prototype.create = function (emailEventHeader) {
    return this.bip.post('/api/EmailEventHeaders', emailEventHeader);
};

EmailEventHeaderService.prototype.delete = function (emailEventHeaderId) {
    return this.bip.delete('/api/EmailEventHeaders/' + emailEventHeaderId);
};

EmailEventHeaderService.prototype.update = function (emailEventHeaderId, emailEventHeader) {
    return this.bip.put('/api/EmailEventHeaders/' + emailEventHeaderId, emailEventHeader);
};



function EmbeddedReportSectionService(bip) {
    this.bip = bip;
}

EmbeddedReportSectionService.prototype.all = function () {
    return this.bip.get('/api/EmbeddedReportSections');
};

EmbeddedReportSectionService.prototype.create = function (embeddedReportSection) {
    return this.bip.post('/api/EmbeddedReportSections', embeddedReportSection);
};

EmbeddedReportSectionService.prototype.delete = function (embeddedReportSectionId) {
    return this.bip.delete('/api/EmbeddedReportSections/' + embeddedReportSectionId);
};

EmbeddedReportSectionService.prototype.get = function (embeddedReportSectionId) {
    return this.bip.get('/api/EmbeddedReportSections/' + embeddedReportSectionId);
};

EmbeddedReportSectionService.prototype.update = function (embeddedReportSectionId, embeddedReportSection) {
    return this.bip.put('/api/EmbeddedReportSections/' + embeddedReportSectionId, embeddedReportSection);
};

EmbeddedReportSectionService.prototype.updateAll = function (reportSections) {
    return this.bip.post('/api/EmbeddedReportSections/UpdateAll', reportSections);
};
function EmbeddedReportService(bip) {
    this.bip = bip;
}

EmbeddedReportService.prototype.all = function () {
    return this.bip.get('/api/EmbeddedReports');
};

EmbeddedReportService.prototype.create = function (embeddedReport) {
    return this.bip.post('/api/EmbeddedReports', embeddedReport);
};

EmbeddedReportService.prototype.delete = function (embeddedReportId) {
    return this.bip.delete('/api/EmbeddedReports/' + embeddedReportId);
};

EmbeddedReportService.prototype.get = function (embeddedReportId) {
    return this.bip.get('/api/EmbeddedReports/' + embeddedReportId);
};

EmbeddedReportService.prototype.update = function (embeddedReportId, embeddedReport) {
    return this.bip.put('/api/EmbeddedReports/' + embeddedReportId, embeddedReport);
};

EmbeddedReportService.prototype.tags = function () {
    return this.bip.get('/api/EmbeddedReports/tags');
};
function EmbeddedReportTypeService(bip) {
    this.bip = bip;
}

EmbeddedReportTypeService.prototype.all = function () {
    return this.bip.get('/api/EmbeddedReportTypes');
};
function FormGroupingService(bip) {
    this.bip = bip;
}

FormGroupingService.prototype.all = function () {
    return this.bip.get('/api/FormGroupings');
};

FormGroupingService.prototype.get = function (formGroupingId) {
    return this.bip.get('/api/FormGroupings/' + formGroupingId);
};

FormGroupingService.prototype.create = function (formGrouping) {
    return this.bip.post('/api/FormGroupings', formGrouping);
};

FormGroupingService.prototype.delete = function (formGroupingId) {
    return this.bip.delete('/api/FormGroupings/' + formGroupingId);
};

FormGroupingService.prototype.update = function (formGroupingId, formGrouping) {
    return this.bip.put('/api/FormGroupings/' + formGroupingId, formGrouping);
};



function FormInputService(bip) {
    this.bip = bip;
}

FormInputService.prototype.all = function () {
    return this.bip.get('/api/FormInputs');
};

FormInputService.prototype.get = function (formInputId) {
    return this.bip.get('/api/FormInputs/' + formInputId);
};

FormInputService.prototype.create = function (formInput) {
    return this.bip.post('/api/FormInputs', formInput);
};

FormInputService.prototype.delete = function (formInputId) {
    return this.bip.delete('/api/FormInputs/' + formInputId);
};

FormInputService.prototype.update = function (formInputId, formInput) {
    return this.bip.put('/api/FormInputs/' + formInputId, formInput);
};

FormInputService.prototype.updateValues = function (formInputId, formInputValues) {
    return this.bip.post('/api/FormInputs/' + formInputId + '/Values', formInputValues);
}


function FormSectionService(bip) {
    this.bip = bip;
}

FormSectionService.prototype.all = function () {
    return this.bip.get('/api/FormSections');
};

FormSectionService.prototype.create = function (formSection) {
    return this.bip.post('/api/FormSections', formSection);
};

FormSectionService.prototype.delete = function (formSectionId) {
    return this.bip.delete('/api/FormSections/' + formSectionId);
};

FormSectionService.prototype.get = function (formSectionId) {
    return this.bip.get('/api/FormSections/' + formSectionId);
};

FormSectionService.prototype.update = function (formSectionId, formSection) {
    return this.bip.put('/api/FormSections/' + formSectionId, formSection);
};

FormSectionService.prototype.updateAll = function (formSections) {
    return this.bip.post('/api/FormSections/UpdateAll', formSections);
};
function FormService(bip) {
    this.bip = bip;
}

FormService.prototype.all = function () {
    return this.bip.get('/api/Forms');
};

FormService.prototype.get = function (formId) {
    return this.bip.get('/api/Forms/' + formId);
};

FormService.prototype.add = function (form) {
    return this.bip.post('/api/Forms', form);
};

FormService.prototype.delete = function (formId) {
    return this.bip.delete('/api/Forms/' + formId);
};

FormService.prototype.update = function (formId, form) {
    console.log(form);
    return this.bip.put('/api/Forms/' + formId, form);
};

FormService.prototype.create = function (form) {
    return this.bip.post('/api/Forms/Create', form);
}
FormService.prototype.lookups = function (formId, includeAll) {
    return this.bip.get('/api/Forms/Lookups/' + formId + (includeAll ? '?includeAll=true' : ''));
}

function FormValidationRuleService(bip) {
    this.bip = bip;
}

FormValidationRuleService.prototype.all = function () {
    return this.bip.get('/api/FormValidationRules');
};

FormValidationRuleService.prototype.get = function (formValidationRuleId) {
    return this.bip.get('/api/FormValidationRules/' + formValidationRuleId);
};

FormValidationRuleService.prototype.create = function (formValidationRule) {
    return this.bip.post('/api/FormValidationRules', formValidationRule);
};

FormValidationRuleService.prototype.delete = function (formValidationRuleId) {
    return this.bip.delete('/api/FormValidationRules/' + formValidationRuleId);
};

FormValidationRuleService.prototype.update = function (formValidationRuleId, formValidationRule) {
    return this.bip.put('/api/FormValidationRules/' + formValidationRuleId, formValidationRule);
};



function FunctionHistoryPropertySetService(bip) {
    this.bip = bip;
}

FunctionHistoryPropertySetService.prototype.all = function () {
    return this.bip.get('/api/FunctionHistoryPropertySets');
};

FunctionHistoryPropertySetService.prototype.create = function (functionHistoryPropertySet) {
    return this.bip.post('/api/FunctionHistoryPropertySets', functionHistoryPropertySet);
};

FunctionHistoryPropertySetService.prototype.delete = function (functionHistoryPropertySetId) {
    return this.bip.delete('/api/FunctionHistoryPropertySets/' + functionHistoryPropertySetId);
};

FunctionHistoryPropertySetService.prototype.get = function (functionHistoryPropertySetId) {
    return this.bip.get('/api/FunctionHistoryPropertySets/' + functionHistoryPropertySetId);
};

FunctionHistoryPropertySetService.prototype.update = function (functionHistoryPropertySetId, functionHistoryPropertySet) {
    return this.bip.put('/api/FunctionHistoryPropertySets/' + functionHistoryPropertySetId, functionHistoryPropertySet);
};

FunctionHistoryPropertySetService.prototype.tags = function () {
    return this.bip.get('/api/FunctionHistoryPropertySets/tags');
};
function FunctionHistoryStyleService(bip) {
    this.bip = bip;
}

FunctionHistoryStyleService.prototype.all = function () {
    return this.bip.get('/api/FunctionHistoryStyles');
};

FunctionHistoryStyleService.prototype.create = function (functionHistoryStyle) {
    return this.bip.post('/api/FunctionHistoryStyles', functionHistoryStyle);
};

FunctionHistoryStyleService.prototype.delete = function (functionHistoryStyleId) {
    return this.bip.delete('/api/FunctionHistoryStyles/' + functionHistoryStyleId);
};

FunctionHistoryStyleService.prototype.get = function (functionHistoryStyleId) {
    return this.bip.get('/api/FunctionHistoryStyles/' + functionHistoryStyleId);
};

FunctionHistoryStyleService.prototype.update = function (functionHistoryStyleId, functionHistoryStyle) {
    return this.bip.put('/api/FunctionHistoryStyles/' + functionHistoryStyleId, functionHistoryStyle);
};

FunctionHistoryStyleService.prototype.tags = function () {
    return this.bip.get('/api/FunctionHistoryStyles/tags');
};
function GroupAssetPermissionService(bip) {
    this.bip = bip;
}

GroupAssetPermissionService.prototype.all = function () {
    return this.bip.get('/api/GroupAssetPermissions');
};

GroupAssetPermissionService.prototype.getForGroup = function (groupId) {
    return this.bip.get('/api/GroupAssetPermissions/' + groupId);
};

GroupAssetPermissionService.prototype.add = function (GroupAssetPermission) {
    return this.bip.post('/api/GroupAssetPermissions/', GroupAssetPermission);
};

GroupAssetPermissionService.prototype.delete = function (GroupAssetPermissionId) {
    return this.bip.delete('/api/GroupAssetPermissions/' + GroupAssetPermissionId);
};

GroupAssetPermissionService.prototype.update = function (GroupAssetPermission) {
    return this.bip.put('/api/GroupAssetPermissions/', GroupAssetPermission);
};


function GroupFormPermissionService(bip) {
    this.bip = bip;
}

GroupFormPermissionService.prototype.all = function () {
    return this.bip.get('/api/GroupFormPermissions');
};

GroupFormPermissionService.prototype.get = function (groupFormPermissionId) {
    return this.bip.get('/api/GroupFormPermissions/' + groupFormPermissionId);
};

GroupFormPermissionService.prototype.getByGroupForm = function (groupId, formId) {
    return this.bip.get('/api/Groups/' + groupId + '/Forms/' + formId + '/GroupFormPermissions');
    
};

GroupFormPermissionService.prototype.create = function (groupFormPermission) {
    return this.bip.post('/api/GroupFormPermissions', groupFormPermission);
};

GroupFormPermissionService.prototype.delete = function (groupFormPermissionId) {
    return this.bip.delete('/api/GroupFormPermissions/' + groupFormPermissionId);
};

GroupFormPermissionService.prototype.update = function (groupFormPermissionId, groupFormPermission) {
    return this.bip.put('/api/GroupFormPermissions/' + groupFormPermissionId, groupFormPermission);
};

GroupFormPermissionService.prototype.allGroup = function (groupID) {
    return this.bip.get('/api/GroupFormPermissions/Group/' + groupID);
}
function GroupLinkService(bip) {
    this.bip = bip;
}

GroupLinkService.prototype.getFrom = function (groupId) {
    return this.bip.get('/api/Groups/From/' + groupId);
};

GroupLinkService.prototype.getTo = function (groupId) {
    return this.bip.get('/api/Groups/To/' + groupId);
};

GroupLinkService.prototype.all = function () {
    return this.bip.get('/api/Groups/Links');
};

GroupLinkService.prototype.getForApproval = function () {
    return this.bip.get('/api/Groups/Links/Approval');
};

GroupLinkService.prototype.update = function (fromGroupId, toGroupId, link) {
    return this.bip.put('/api/Groups/From/' + fromGroupId + '/To/' + toGroupId, link);
};

GroupLinkService.prototype.add = function (link) {
    return this.bip.post('/api/Groups/Links', link);
};

GroupLinkService.prototype.remove = function (fromGroupId, toGroupId) {
    return this.bip.delete('/api/Groups/From/' + fromGroupId + '/To/' + toGroupId);
};
function GroupPlanningBoardPermissionService(bip) {
    this.bip = bip;
}

GroupPlanningBoardPermissionService.prototype.all = function () {
    return this.bip.get('/api/GroupPlanningBoardPermissions');
};

GroupPlanningBoardPermissionService.prototype.get = function (groupPlanningBoardPermissionId) {
    return this.bip.get('/api/GroupPlanningBoardPermissions/' + groupPlanningBoardPermissionId);
};

GroupPlanningBoardPermissionService.prototype.getByGroupPlanningBoard = function (groupId, planningBoardId) {
    return this.bip.get('/api/Groups/' + groupId + '/PlanningBoards/' + planningBoardId + '/GroupPlanningBoardPermissions');
    
};

GroupPlanningBoardPermissionService.prototype.create = function (groupPlanningBoardPermission) {
    return this.bip.post('/api/GroupPlanningBoardPermissions', groupPlanningBoardPermission);
};

GroupPlanningBoardPermissionService.prototype.delete = function (groupPlanningBoardPermissionId) {
    return this.bip.delete('/api/GroupPlanningBoardPermissions/' + groupPlanningBoardPermissionId);
};

GroupPlanningBoardPermissionService.prototype.update = function (groupPlanningBoardPermissionId, groupPlanningBoardPermission) {
    return this.bip.put('/api/GroupPlanningBoardPermissions/' + groupPlanningBoardPermissionId, groupPlanningBoardPermission);
};

GroupPlanningBoardPermissionService.prototype.allGroup = function (groupID) {
    return this.bip.get('/api/GroupPlanningBoardPermissions/Group/' + groupID);
}
function GroupReportPermissionService(bip) {
    this.bip = bip;
}

GroupReportPermissionService.prototype.all = function () {
    return this.bip.get('/api/GroupReportPermissions');
};

GroupReportPermissionService.prototype.get = function (groupReportPermissionId) {
    return this.bip.get('/api/GroupReportPermissions/' + groupReportPermissionId);
};

GroupReportPermissionService.prototype.getByGroupReport = function (groupId, reportId) {
    return this.bip.get('/api/Groups/' + groupId + '/Reports/' + reportId + '/GroupReportPermissions');
    
};

GroupReportPermissionService.prototype.create = function (groupReportPermission) {
    return this.bip.post('/api/GroupReportPermissions', groupReportPermission);
};

GroupReportPermissionService.prototype.delete = function (groupReportPermissionId) {
    return this.bip.delete('/api/GroupReportPermissions/' + groupReportPermissionId);
};

GroupReportPermissionService.prototype.update = function (groupReportPermissionId, groupReportPermission) {
    return this.bip.put('/api/GroupReportPermissions/' + groupReportPermissionId, groupReportPermission);
};

GroupReportPermissionService.prototype.allGroup = function (groupID) {
    return this.bip.get('/api/GroupReportPermissions/Group/' + groupID);
}
function GroupService(bip) {
    this.bip = bip;
}

GroupService.prototype.all = function (orderedByGroupLinks) {
    return this.bip.get('/api/Groups' + (orderedByGroupLinks ? '?orderedByGroupLinks=true' : ''));
};

GroupService.prototype.get = function (groupId) {
    return this.bip.get('/api/Groups/' + groupId);
};

GroupService.prototype.getForApproval = function (orderedByGroupLinks) {
    return this.bip.get('/api/Groups/Approval/' + (orderedByGroupLinks ? '?orderedByGroupLinks=true' : ''));
};

GroupService.prototype.create = function (group) {
    return this.bip.post('/api/Groups', group);
};

GroupService.prototype.delete = function (groupId) {
    return this.bip.delete('/api/Groups/' + groupId);
};

GroupService.prototype.update = function (groupId, group) {
    return this.bip.put('/api/Groups/' + groupId, group);
};

GroupService.prototype.getState = function (groupId) {
    return this.bip.get('/api/Groups/State/' + groupId);
};
GroupService.prototype.allStates = function () {
    return this.bip.get('/api/Groups/States');
};

GroupService.prototype.setState = function (groupId, stateId) {
    return this.bip.put('/api/Groups/State/' + groupId, { stateId: stateId });
};

GroupService.prototype.setHorizontal = function (groupId, horizontal) {
    return this.bip.put('/api/Groups/Horizontal/' + groupId, horizontal);
};

GroupService.prototype.updateIndexNumber = function (groupId, index) {
    return this.bip.put('/api/Groups/Index/' + groupId, index);
};

GroupService.prototype.sortGroupsByGroupLinks = function (groups, groupLinks) {
    $scope.groups.length = 0;
    Array.prototype.push.apply($scope.groups, results[0]);
    $scope.groups.forEach(function (group) {
        group.items = [];
        tree.push({
            group: group,
            children: []
        });
    });

    var removals = [];
    results[1].forEach(function (link) {
        links.push(link);
        var parent = tree.find(function (branch) { return branch.group.ID === link.FromID; });
        var child = tree.find(function (branch) { return branch.group.ID === link.ToID; });
        child.horizontal = link.Horizontal;
        parent.children.push(child);
        removals.push(child);
    });

    removals.forEach(function (branch) {
        tree.remove(branch);
    });

    var treeSort = function (tree) {
        tree.sort(function (a, b) {
            return a.group.Index - b.group.Index;
        });
        tree.forEach(function (branch) {
            if (branch.children.length > 0) {
                branch.children.forEach(function (child) { treeSort(child.children); });
            }
        });
    };

    treeSort(tree);

    var order = [];

    var branchOrderID = function (branches) {
        branches.forEach(function (branch) {
            order.push(branch.group.ID);
            if (branch.children.length > 0) {
                branchOrderID(branch.children);
            }
        });
    };

    branchOrderID(tree);

    var rearrangeGroups = $scope.groups.map(function (item) {
        var n = order.indexOf(item.ID);
        order[n] = '';
        return [n, item];
    }).sort().map(function (j) { return j[1]; });
}

GroupService.prototype.tags = function () {
    return this.bip.get('/api/Groups/tags');
};

GroupService.prototype.save = function (values) {
    return this.bip.put('/api/Groups/Update', values);
};
function GroupTypeService(bip) {
    this.bip = bip;
}


GroupTypeService.prototype.all = function () {
    return this.bip.get('/api/GroupTypes');
};

GroupTypeService.prototype.get = function (groupTypeId) {
    return this.bip.get('/api/GroupTypes/' + groupTypeId);
};

GroupTypeService.prototype.update = function (groupTypeId, groupType) {
    return this.bip.put('/api/GroupTypes/' + groupTypeId, groupType);
};

GroupTypeService.prototype.add = function (groupType) {
    return this.bip.post('/api/GroupTypes', groupType);
};

GroupTypeService.prototype.remove = function (groupTypeId) {
    return this.bip.delete('/api/GroupTypes/' + groupTypeId);
};
function HelpGroupingService(bip) {
    this.bip = bip;
}

HelpGroupingService.prototype.all = function () {
    return this.bip.get('/api/HelpGroupings');
};

HelpGroupingService.prototype.create = function (helpGrouping) {
    return this.bip.post('/api/HelpGroupings', helpGrouping);
};

HelpGroupingService.prototype.delete = function (helpGroupingId) {
    return this.bip.delete('/api/HelpGroupings/' + helpGroupingId);
};

HelpGroupingService.prototype.get = function (helpGroupingId) {
    return this.bip.get('/api/HelpGroupings/' + helpGroupingId);
};

HelpGroupingService.prototype.update = function (helpGroupingId, helpGrouping) {
    return this.bip.put('/api/HelpGroupings/' + helpGroupingId, helpGrouping);
};

HelpGroupingService.prototype.updateAll = function (helpSection) {
    return this.bip.post('/api/HelpGroupings/UpdateAll', helpSection);
};
function HelpService(bip) {
    this.bip = bip;
}

HelpService.prototype.all = function () {
    return this.bip.get('/api/Help');
};

HelpService.prototype.create = function (item) {
    return this.bip.post('/api/Help', item);
};
HelpService.prototype.upload = function (itemId, file, key, scope) {
    var data = new FormData();
    data.append('file', file, file.name);
    console.log(itemId); var data = new FormData();
    data.append('file', file, file.name);
    var prom = new Promise(function (resolve, reject) {
        var maxBlockSize = 256 * 1024;//Each file will be split in 256 KB.
        var numberOfBlocks = 1;
        var selectedFile = null;
        var currentFilePointer = 0;
        var totalBytesRemaining = 0;
        var blockIds = new Array();
        var blockIdPrefix = "block-";
        var submitUri = null;
        var bytesUploaded = 0;

        maxBlockSize = 256 * 1024;
        currentFilePointer = 0;
        totalBytesRemaining = 0;
        selectedFile = file;
        var fileSize = file.size;
        if (fileSize < maxBlockSize) {
            maxBlockSize = fileSize;
        }
        totalBytesRemaining = fileSize;
        if (fileSize % maxBlockSize == 0) {
            numberOfBlocks = fileSize / maxBlockSize;
        } else {
            numberOfBlocks = parseInt(fileSize / maxBlockSize, 10) + 1;
        }
        submitUri = 'http://blobs.bip.nz/helpvideos/hv-' + itemId + key;

        var reader = new FileReader();

        reader.onloadend = function (evt) {
            if (evt.target.readyState == FileReader.DONE) { // DONE == 2
                var uri = submitUri + '&comp=block&blockid=' + blockIds[blockIds.length - 1];
                var requestData = new Uint8Array(evt.target.result);
                $.ajax({
                    url: uri,
                    type: "PUT",
                    data: requestData,
                    processData: false,
                    beforeSend: function (xhr) {
                        xhr.setRequestHeader('x-ms-blob-type', 'BlockBlob');
                    },
                    success: function (data, status) {
                        bytesUploaded += requestData.length;
                        scope.progress = ((parseFloat(bytesUploaded) / parseFloat(selectedFile.size)) * 100).toFixed(2);
                        scope.$apply();
                        uploadFileInBlocks();
                    },
                    error: function (xhr, desc, err) {
                        console.log(desc);
                        console.log(err);
                    }
                });
            }
        };

        function uploadFileInBlocks() {
            if (totalBytesRemaining > 0) {
                var fileContent = selectedFile.slice(currentFilePointer, currentFilePointer + maxBlockSize);
                var blockId = blockIdPrefix + pad(blockIds.length, 6);
                blockIds.push(btoa(blockId));
                reader.readAsArrayBuffer(fileContent);
                currentFilePointer += maxBlockSize;
                totalBytesRemaining -= maxBlockSize;
                if (totalBytesRemaining < maxBlockSize) {
                    maxBlockSize = totalBytesRemaining;
                }
            } else {
                commitBlockList();
            }
        }

        function commitBlockList() {
            var uri = submitUri + '&comp=blocklist';
            var requestBody = '<?xml version="1.0" encoding="utf-8"?><BlockList>';
            for (var i = 0; i < blockIds.length; i++) {
                requestBody += '<Latest>' + blockIds[i] + '</Latest>';
            }
            requestBody += '</BlockList>';
            $.ajax({
                url: uri,
                type: "PUT",
                data: requestBody,
                beforeSend: function (xhr) {
                    xhr.setRequestHeader('x-ms-blob-content-type', selectedFile.type);
                },
                success: function (data, status) {
                    resolve();
                },
                error: function (xhr, desc, err) {
                    console.log(desc);
                    console.log(err);
                }
            });

        }
        function pad(number, length) {
            var str = '' + number;
            while (str.length < length) {
                str = '0' + str;
            }
            return str;
        }
        uploadFileInBlocks();
    })
    return prom;

    //return this.bip.upload('/api/Videos/'+videoId+'/upload', data);
};

HelpService.prototype.delete = function (itemId) {
    return this.bip.delete('/api/Help/' + itemId);
};

HelpService.prototype.get = function (itemId) {
    return this.bip.get('/api/Help/' + itemId);
};

HelpService.prototype.update = function (itemId, item) {
    return this.bip.put('/api/Help/' + itemId, item);
};

HelpService.prototype.tags = function () {
    return this.bip.get('/api/Help/tags');
};

HelpService.prototype.types = function () {
    return this.bip.get('/api/Help/Types');
};
function HomeArticleService(bip) {
    this.bip = bip;
}

HomeArticleService.prototype.all = function () {
    return this.bip.get('/api/HomeArticles').then(function (articles) {
        articles.forEach(function (article) {
            article.Timestamp = new Date(article.Timestamp);
        });
        return articles;
    });
};

HomeArticleService.prototype.create = function (homeArticle) {
    return this.bip.post('/api/HomeArticles', homeArticle);
};

HomeArticleService.prototype.delete = function (homeArticleId) {
    return this.bip.delete('/api/HomeArticles/' + homeArticleId);
};

HomeArticleService.prototype.get = function (homeArticleId) {
    return this.bip.get('/api/HomeArticles/' + homeArticleId).then(function (article) {
        article.Timestamp = new Date(article.Timestamp);
        return article;
    });
    return this.bip.get('/api/HomeArticles/' + homeArticleId);
};

HomeArticleService.prototype.update = function (homeArticleId, homeArticle) {
    return this.bip.put('/api/HomeArticles/' + homeArticleId, homeArticle);
};

HomeArticleService.prototype.upload = function (homeArticleId, file, appendix, key, scope) {
    var data = new FormData();
    data.append('file', file, file.name);
    var prom = new Promise(function (resolve, reject) {
    var maxBlockSize = 256 * 1024;//Each file will be split in 256 KB.
    var numberOfBlocks = 1;
    var selectedFile = null;
    var currentFilePointer = 0;
    var totalBytesRemaining = 0;
    var blockIds = new Array();
    var blockIdPrefix = "block-";
    var submitUri = null;
    var bytesUploaded = 0;
    
        maxBlockSize = 256 * 1024;
        currentFilePointer = 0;
        totalBytesRemaining = 0;
        selectedFile = file;
        var fileSize = file.size;
        if (fileSize < maxBlockSize) {
            maxBlockSize = fileSize;
        }
        totalBytesRemaining = fileSize;
        if (fileSize % maxBlockSize == 0) {
            numberOfBlocks = fileSize / maxBlockSize;
        } else {
            numberOfBlocks = parseInt(fileSize / maxBlockSize, 10) + 1;
        }
        submitUri = 'https://blobs.bip.nz/articlemedia/am-' + homeArticleId + (appendix !== undefined ? '-' + appendix : '') + key;

    var reader = new FileReader();

    reader.onloadend = function (evt) {
        if (evt.target.readyState == FileReader.DONE) { // DONE == 2
            var uri = submitUri + '&comp=block&blockid=' + blockIds[blockIds.length - 1];
            var requestData = new Uint8Array(evt.target.result);
            $.ajax({
                url: uri,
                type: "PUT",
                data: requestData,
                processData: false,
                beforeSend: function (xhr) {
                    xhr.setRequestHeader('x-ms-blob-type', 'BlockBlob');
                },
                success: function (data, status) {
                    bytesUploaded += requestData.length;
                    scope.progress[appendix] = ((parseFloat(bytesUploaded) / parseFloat(selectedFile.size)) * 100).toFixed(2);
                    scope.$apply();
                    uploadFileInBlocks();
                },
                error: function (xhr, desc, err) {
                    console.log(desc);
                    console.log(err);
                }
            });
        }
    };

    function uploadFileInBlocks() {
        if (totalBytesRemaining > 0) {
            var fileContent = selectedFile.slice(currentFilePointer, currentFilePointer + maxBlockSize);
            var blockId = blockIdPrefix + pad(blockIds.length, 6);
            blockIds.push(btoa(blockId));
            reader.readAsArrayBuffer(fileContent);
            currentFilePointer += maxBlockSize;
            totalBytesRemaining -= maxBlockSize;
            if (totalBytesRemaining < maxBlockSize) {
                maxBlockSize = totalBytesRemaining;
            }
        } else {
            commitBlockList();
        }
    }

    function commitBlockList() {
        var uri = submitUri + '&comp=blocklist';
        var requestBody = '<?xml version="1.0" encoding="utf-8"?><BlockList>';
        for (var i = 0; i < blockIds.length; i++) {
            requestBody += '<Latest>' + blockIds[i] + '</Latest>';
        }
        requestBody += '</BlockList>';
        $.ajax({
            url: uri,
            type: "PUT",
            data: requestBody,
            beforeSend: function (xhr) {
                xhr.setRequestHeader('x-ms-blob-content-type', selectedFile.type);
            },
            success: function (data, status) {
                resolve();
            },
            error: function (xhr, desc, err) {
                console.log(desc);
                console.log(err);
            }
        });

    }
    function pad(number, length) {
        var str = '' + number;
        while (str.length < length) {
            str = '0' + str;
        }
        return str;
    }
    uploadFileInBlocks();
    })
    return prom;
    //return this.bip.put('https://blobs.bip.nz/articlemedia/am-' + homeArticleId + (appendix !== undefined ? '/' + appendix : '') + key, data);
};

HomeArticleService.prototype.deleteMedia = function (homeArticleId, appendix) {
    return this.bip.delete('/api/HomeArticles/' + homeArticleId + '/deleteMedia' + (appendix ? '/' + appendix + '/' : ''));
};
function HomeLinkService(bip) {
    this.bip = bip;
}

HomeLinkService.prototype.all = function () {
    return this.bip.get('/api/HomeLinks');
};

HomeLinkService.prototype.create = function (icon) {
    return this.bip.post('/api/HomeLinks', icon);
};

HomeLinkService.prototype.delete = function (iconId) {
    return this.bip.delete('/api/HomeLinks/' + iconId);
};

HomeLinkService.prototype.get = function (iconId) {
    return this.bip.get('/api/HomeLinks/' + iconId);
};

HomeLinkService.prototype.update = function (iconId, icon) {
    return this.bip.put('/api/HomeLinks/' + iconId, icon);
};
function HomeMessageService(bip) {
    this.bip = bip;
}

HomeMessageService.prototype.all = function () {
    return this.bip.get('/api/HomeMessages').then(function (messages) {
        messages.forEach(function (message) {
            message.Timestamp = new Date(message.Timestamp);
        });
        return messages;
    });
};

HomeMessageService.prototype.create = function (homeMessage) {
    return this.bip.post('/api/HomeMessages', homeMessage);
};

HomeMessageService.prototype.delete = function (homeMessageId) {
    return this.bip.delete('/api/HomeMessages/' + homeMessageId);
};

HomeMessageService.prototype.get = function (homeMessageId) {
    return this.bip.get('/api/HomeMessages/' + homeMessageId).then(function (message) {
        message.Timestamp = new Date(message.Timestamp);
        return message;
    });
    return this.bip.get('/api/HomeMessages/' + homeMessageId);
};

HomeMessageService.prototype.update = function (homeMessageId, homeMessage) {
    return this.bip.put('/api/HomeMessages/' + homeMessageId, homeMessage);
};
function HomeMessageTypeService(bip) {
    this.bip = bip;
}

HomeMessageTypeService.prototype.all = function () {
    return this.bip.get('/api/HomeMessageTypes').then(function (messages) {
        messages.forEach(function (message) {
            message.Timestamp = new Date(message.Timestamp);
        });
        return messages;
    });
};

HomeMessageTypeService.prototype.create = function (homeMessageType) {
    return this.bip.post('/api/HomeMessageTypes', homeMessageType);
};

HomeMessageTypeService.prototype.delete = function (homeMessageTypeId) {
    return this.bip.delete('/api/HomeMessageTypes/' + homeMessageTypeId);
};

HomeMessageTypeService.prototype.get = function (homeMessageTypeId) {
    return this.bip.get('/api/HomeMessageTypes/' + homeMessageTypeId).then(function (message) {
        message.Timestamp = new Date(message.Timestamp);
        return message;
    });
    return this.bip.get('/api/HomeMessageTypes/' + homeMessageTypeId);
};

HomeMessageTypeService.prototype.update = function (homeMessageTypeId, homeMessageType) {
    return this.bip.put('/api/HomeMessageTypes/' + homeMessageTypeId, homeMessageType);
};
function HomeNewsletterService(bip) {
    this.bip = bip;
}

HomeNewsletterService.prototype.all = function () {
    return this.bip.get('/api/HomeNewsletters').then(function (newsletters) {
        newsletters.forEach(function (newsletter) {
            newsletter.Timestamp = new Date(newsletter.Timestamp);
        });
        return newsletters;
    });
};

HomeNewsletterService.prototype.create = function (homeNewsletter) {
    return this.bip.post('/api/HomeNewsletters', homeNewsletter);
};

HomeNewsletterService.prototype.delete = function (homeNewsletterId) {
    return this.bip.delete('/api/HomeNewsletters/' + homeNewsletterId);
};

HomeNewsletterService.prototype.get = function (homeNewsletterId) {
    return this.bip.get('/api/HomeNewsletters/' + homeNewsletterId).then(function (newsletter) {
        newsletter.Timestamp = new Date(newsletter.Timestamp);
        return newsletter;
    });
    return this.bip.get('/api/HomeNewsletters/' + homeNewsletterId);
};

HomeNewsletterService.prototype.update = function (homeNewsletterId, homeNewsletter) {
    return this.bip.put('/api/HomeNewsletters/' + homeNewsletterId, homeNewsletter);
};

HomeNewsletterService.prototype.upload = function (homeNewsletterId, file, appendix) {
    var data = new FormData();
    data.append('file', file, file.name);
    return this.bip.upload('/api/HomeNewsletters/' + homeNewsletterId + '/upload' + (appendix !== undefined ?  '/'+appendix : ''), data);
};

HomeNewsletterService.prototype.deleteMedia = function (homeNewsletterId, appendix) {
    return this.bip.delete('/api/HomeNewsletters/' + homeNewsletterId + '/deleteMedia' + (appendix ? '/' + appendix + '/' : ''));
};
function IconService(bip) {
    this.bip = bip;
}

IconService.prototype.all = function () {
    return this.bip.get('/api/Icons');
};

IconService.prototype.create = function (icon) {
    return this.bip.post('/api/Icons', icon);
};

IconService.prototype.delete = function (iconId) {
    return this.bip.delete('/api/Icons/' + iconId);
};

IconService.prototype.get = function (iconId) {
    return this.bip.get('/api/Icons/' + iconId);
};

IconService.prototype.update = function (iconId, icon) {
    return this.bip.put('/api/Icons/' + iconId, icon);
};

IconService.prototype.addAllToCdn = function () {
    return this.bip.get('/api/Icons/AddToCdn');
};

IconService.prototype.addToCdn = function (iconId) {
    return this.bip.get('/api/Icons/' + iconId + '/AddToCdn');
};

IconService.prototype.removeFromCdn = function (iconId) {
    return this.bip.get('/api/Icons/' + iconId + '/RemoveFromCdn');
};

IconService.prototype.addRotationsToCdn = function (iconId, playback) {
    return this.bip.get('/api/Icons/' + iconId + '/AddRotationsToCdn/' + (playback ? 'true' : 'false'));
};

IconService.prototype.removeRotationsFromCdn = function (iconId, playback) {
    return this.bip.get('/api/Icons/' + iconId + '/RemoveRotationsFromCdn/' + (playback ? 'true' : 'false'));
};

IconService.prototype.setAspectRatios = function () {
    return this.bip.get('/api/Icons/SetAspectRatios');
};

IconService.prototype.tags = function () {
    return this.bip.get('/api/Icons/tags');
};
function IconSetService(bip) {
    this.bip = bip;
}

IconSetService.prototype.all = function () {
    return this.bip.get('/api/IconSets');
};

IconSetService.prototype.create = function (wfsIconSet) {
    return this.bip.post('/api/IconSets', wfsIconSet);
};

IconSetService.prototype.delete = function (wfsIconSetId) {
    return this.bip.delete('/api/IconSets/' + wfsIconSetId);
};

IconSetService.prototype.get = function (wfsIconSetId) {
    return this.bip.get('/api/IconSets/' + wfsIconSetId);
};

IconSetService.prototype.update = function (wfsIconSetId, wfsIconSet) {
    return this.bip.put('/api/IconSets/' + wfsIconSetId, wfsIconSet);
};

IconSetService.prototype.addToCdn = function (wfsIconSetId) {
    return this.bip.get('/api/IconSets/' + wfsIconSetId + '/AddToCdn');
}; 

IconSetService.prototype.removeFromCdn = function (wfsIconSetId) {
    return this.bip.get('/api/IconSets/' + wfsIconSetId + '/RemoveFromCdn');
};

IconSetService.prototype.addAllToCdn = function () {
    return this.bip.get('/api/IconSets/AddToCdn');
};

IconSetService.prototype.addIconCombinationsToCdn = function (iconId) {
    return this.bip.get('/api/IconSets/' + iconId + '/AddIconCombinationsToCdn');
};

IconSetService.prototype.tags = function () {
    return this.bip.get('/api/IconSets/tags');
};
function LayerSectionService(bip) {
    this.bip = bip;
}

LayerSectionService.prototype.all = function () {
    return this.bip.get('/api/LayerSections');
};

LayerSectionService.prototype.create = function (layerSection) {
    return this.bip.post('/api/LayerSections', layerSection);
};

LayerSectionService.prototype.delete = function (layerSectionId) {
    return this.bip.delete('/api/LayerSections/' + layerSectionId);
};

LayerSectionService.prototype.get = function (layerSectionId) {
    return this.bip.get('/api/LayerSections/' + layerSectionId);
};

LayerSectionService.prototype.update = function (layerSectionId, layerSection) {
    return this.bip.put('/api/LayerSections/' + layerSectionId, layerSection);
};

LayerSectionService.prototype.updateAll = function (layerSections) {
    return this.bip.post('/api/LayerSections/UpdateAll', layerSections);
};
function LayerService(bip) {
    this.bip = bip;
}

LayerService.prototype.all = function () {
    return this.bip.get('/api/Layers');
};

LayerService.prototype.create = function (layer) {
    return this.bip.post('/api/Layers', layer);
};

LayerService.prototype.delete = function (layerId) {
    return this.bip.delete('/api/Layers/' + layerId);
};

LayerService.prototype.get = function (layerId) {
    return this.bip.get('/api/Layers/' + layerId);
};

LayerService.prototype.update = function (layerId, layer) {
    return this.bip.put('/api/Layers/' + layerId, layer);
};

LayerService.prototype.tags = function () {
    return this.bip.get('/api/Layers/tags');
}
function PermissionRequestService(bip) {
    this.bip = bip;
}

PermissionRequestService.prototype.getPendingRequestsForCurrentUser = function () {
    return this.bip.get('/api/PermissionRequests/GetPendingRequestsForCurrentUser');
};

PermissionRequestService.prototype.getPendingRequests = function (id) {
    return this.bip.get('/api/PermissionRequests/GetPendingRequests/' + id);
};

PermissionRequestService.prototype.getResolvedRequests = function (id) {
    return this.bip.get('/api/PermissionRequests/GetResolvedRequests/' + id );
};

PermissionRequestService.prototype.add = function (roleId, groupIds) {
    return this.bip.post('/api/PermissionRequests/add/' + roleId, groupIds);
};

PermissionRequestService.prototype.resolve = function (request) {
    return this.bip.put('/api/PermissionRequests/Resolve', request);
};

PermissionRequestService.prototype.listPendingRequests = function () {
    return this.bip.get('/api/PermissionRequests/ListPendingRequests');
};

PermissionRequestService.prototype.listResolvedRequests = function () {
    return this.bip.get('/api/PermissionRequests/ListResolvedRequests');
};

PermissionRequestService.prototype.revokeGroup = function (requestId) {
    return this.bip.put('/api/PermissionRequests/revokeGroup/' + requestId);
};

PermissionRequestService.prototype.revokeRole = function (requestId) {
    return this.bip.put('/api/PermissionRequests/revokeRole/' + requestId);
};
function PlanningBoardService(bip) {
    this.bip = bip;
}

PlanningBoardService.prototype.all = function () {
    return this.bip.get('/api/PlanningBoards');
};

PlanningBoardService.prototype.create = function (planningBoard) {
    return this.bip.post('/api/PlanningBoards', planningBoard);
};

PlanningBoardService.prototype.delete = function (planningBoardId) {
    return this.bip.delete('/api/PlanningBoards/' + planningBoardId);
};

PlanningBoardService.prototype.get = function (planningBoardId) {
    return this.bip.get('/api/PlanningBoards/' + planningBoardId);
};

PlanningBoardService.prototype.update = function (planningBoardId, planningBoard) {
    return this.bip.put('/api/PlanningBoards/' + planningBoardId, planningBoard);
};


function ProjectFormService(bip) {
    this.bip = bip;
}

ProjectFormService.prototype.all = function () {
    return this.bip.get('/api/ProjectForms');
};

ProjectFormService.prototype.create = function (projectForm) {
    return this.bip.post('/api/ProjectForms', projectForm);
};

ProjectFormService.prototype.delete = function (projectId, formId) {
    return this.bip.delete('/api/ProjectForms/' + projectId + '/' + formId);
};

ProjectFormService.prototype.get = function (projectId, formId) {
    return this.bip.get('/api/ProjectForms/' + projectId + '/' + formId);
};

ProjectFormService.prototype.update = function (projectId, formId, projectForm) {
    return this.bip.put('/api/ProjectForms/' + projectId + '/' + formId, projectForm);
};
function ProjectService(bip) {
    this.bip = bip;
}

ProjectService.prototype.all = function () {
    return this.bip.get('/api/Projects');
};

ProjectService.prototype.create = function (project) {
    return this.bip.post('/api/Projects', project, true);
};

ProjectService.prototype.delete = function (projectId) {
    return this.bip.delete('/api/Projects/' + projectId);
};

ProjectService.prototype.get = function (projectId) {
    return this.bip.get('/api/Projects/' + projectId);
};

ProjectService.prototype.getByDate = function (date) {
    return this.bip.get('/api/Projects/ByDate?date=' + encodeURIComponent(date));
};

ProjectService.prototype.update = function (projectId, project) {
    return this.bip.put('/api/Projects/' + projectId, project, true);
};
ProjectService.prototype.schema = function () {
    return this.bip.get('/api/Projects/Schema');
};
function PropertySetService(bip) {
    this.bip = bip;
}

PropertySetService.prototype.all = function () {
    return this.bip.get('/api/PropertySets');
};

PropertySetService.prototype.create = function (propertySet) {
    return this.bip.post('/api/PropertySets', propertySet);
};

PropertySetService.prototype.delete = function (propertySetId) {
    return this.bip.delete('/api/PropertySets/' + propertySetId);
};

PropertySetService.prototype.get = function (propertySetId) {
    return this.bip.get('/api/PropertySets/' + propertySetId);
};

PropertySetService.prototype.update = function (propertySetId, propertySet) {
    return this.bip.put('/api/PropertySets/' + propertySetId, propertySet);
};

PropertySetService.prototype.tags = function () {
    return this.bip.get('/api/PropertySets/tags');
};
function RammCredentialsService(bip) {
    this.bip = bip;
};

RammCredentialsService.prototype.get = function () {
    return this.bip.get('/api/RammCredentials');
};

RammCredentialsService.prototype.set = function (value) {
    return this.bip.post('/api/RammCredentials', value);
};
function SystemRammTableService(bip) {
    this.bip = bip;
}

SystemRammTableService.prototype.all = function () {
    return this.bip.get('/api/RammTables');
};

SystemRammTableService.prototype.get = function (rammTableId) {
    return this.bip.get('/api/RammTables/' + rammTableId);
};

SystemRammTableService.prototype.create = function (rammTable) {
    return this.bip.post('/api/RammTables', rammTable);
};

SystemRammTableService.prototype.delete = function (rammTableId) {
    return this.bip.delete('/api/RammTables/' + rammTableId);
};

SystemRammTableService.prototype.update = function (rammTableId, rammTable) {
    return this.bip.put('/api/RammTables/' + rammTableId, rammTable);
};


function RammTableSystemColumnService(bip) {
    this.bip = bip;
}

RammTableSystemColumnService.prototype.all = function () {
    return this.bip.get('/api/RammTableSystemColumns');
};


function ReportService(bip) {
    this.bip = bip;
}

ReportService.prototype.all = function () {
    return this.bip.get('/api/Reports');
};

ReportService.prototype.create = function (report) {
    return this.bip.post('/api/Reports', report);
};

ReportService.prototype.delete = function (reportId) {
    return this.bip.delete('/api/Reports/' + reportId);
};

ReportService.prototype.get = function (reportId) {
    return this.bip.get('/api/Reports/' + reportId);
};

ReportService.prototype.update = function (reportId, report) {
    return this.bip.put('/api/Reports/' + reportId, report);
};

ReportService.prototype.tags = function () {
    return this.bip.get('/api/Reports/tags');
};
function RoleService(bip) {
    this.bip = bip;
}

RoleService.prototype.all = function () {
    return this.bip.get('/api/Roles');
};

RoleService.prototype.create = function (role) {
    return this.bip.post('/api/Roles', role);
};

RoleService.prototype.delete = function (roleId) {
    return this.bip.delete('/api/Roles/' + roleId);
};

RoleService.prototype.get = function (roleId) {
    return this.bip.get('/api/Roles/' + roleId);
};

RoleService.prototype.update = function (roleId, role) {
    return this.bip.put('/api/Roles/' + roleId, role);
};

RoleService.prototype.getUserIds = function (roleId) {
    return this.bip.get('/api/Roles/' + roleId + '/Users');
};

RoleService.prototype.tags = function () {
    return this.bip.get('/api/Roles/tags');
};
function SettingService(bip) {
    this.bip = bip;
};

SettingService.prototype.all = function () {
    return this.bip.get('/api/Settings');
};

SettingService.prototype.addOrUpdate = function (name, value) {
    return this.bip.post('/api/Settings/' + name+ '/' + value);
};

SettingService.prototype.addOrUpdateMulti = function (values) {
    return this.bip.post('/api/settings', values);
}

SettingService.prototype.delete = function (name) {
    return this.bip.delete('/api/Settings/' + name);
};

SettingService.prototype.get = function (name) {
    return this.bip.get('/api/Settings/' + name);
};
function SourceService(bip, $http) {
    this.bip = bip;
    this.http = $http;
}

SourceService.prototype.all = function () {
    return this.bip.get('/api/Sources').then(function (sources) {
        sources.forEach(function (source) { 
            source.LastVerified = new Date(source.LastVerified);
        });
        return sources;
    });
};

SourceService.prototype.create = function (source) {
    return this.bip.post('/api/Sources', source);
};

SourceService.prototype.delete = function (sourceId) {
    return this.bip.delete('/api/Sources/' + sourceId);
};

SourceService.prototype.get = function (sourceId) {
    return this.bip.get('/api/Sources/' + sourceId).then(function (source) {
        source.LastVerified = new Date(source.LastVerified);
        return source;
    });
};

SourceService.prototype.update = function (sourceId, source) {
    return this.bip.put('/api/Sources/' + sourceId, source);
};

SourceService.prototype.getUserIds = function (sourceId) {
    return this.bip.get('/api/Sources/' + sourceId + '/Users');
};

SourceService.prototype.verifySource = function (source, callback) {
    source.isVerifying = true;
    source.Status = '';
    source.LastVerified = new Date();

    this.http({
        method: 'GET',
        url: source.URL,
    }).then(function successCallback(response) {
        var data = response.data;
        // Get the content type
        var ct = response.headers('Content-Type');

        // If the content type is not json/html
        if (ct.indexOf('json') < 0 && ct.indexOf('html') < 0) {
            source.Status = 'Server returned wrong content type. Got \'' + ct + '\', should have been \'application/json\', \'text/json\' or \'text/html\'';
            source.isVerifying = false;
            if (callback) callback();
            return;
        }

        // If the data is a string, try parse it as json
        if (typeof data === 'string') {
            try {
                data = JSON.parse(data);
            } catch (e) {
                source.Status = 'Server did not return valid \'JSON\'';
                source.isVerifying = false;
                if (callback) callback();
                return;
            }
        }

        // Ensure the server returned a feature collection
        if (data.type !== 'FeatureCollection') {
            source.Status = 'Server did not return a feature collection';
            source.isVerifying = false;
            if (callback) callback();
            return;
        }

        // Ensure the feature collection is not empty
        if (data.totalFeatures < 0) {
            source.Status = 'Server returned an empty feature collection';
            source.isVerifying = false;
            if (callback) callback();
            return;
        }

        source.Status = 'URL was successfully verified!';
        source.isVerifying = false;
        if (callback) callback();
    }, function errorCallback(response) {
        if (status === -1) {
            source.Status = 'Could not contact server to verify source';
        } else {
            source.Status = 'Server error, returned HTTP ' + response.status;
        }
        source.isVerifying = false;
        if (callback) callback();
    });
};

SourceService.prototype.tags = function () {
    return this.bip.get('/api/Sources/tags');
}
function StateService(bip) {
    this.bip = bip;
}

StateService.prototype.all = function () {
    return this.bip.get('/api/States');
};

StateService.prototype.create = function (state) {
    return this.bip.post('/api/States', state);
};

StateService.prototype.delete = function (stateId) {
    return this.bip.delete('/api/States/' + stateId);
};

StateService.prototype.get = function (stateId) {
    return this.bip.get('/api/States/' + stateId);
};

StateService.prototype.update = function (stateId, state) {
    return this.bip.put('/api/States/' + stateId, state);
};

StateService.prototype.getUserIds = function (stateId) {
    return this.bip.get('/api/States/' + stateId + '/Users');
};

StateService.prototype.tags = function () {
    return this.bip.get('/api/States/tags');
};
function SystemColumnService(bip) {
    this.bip = bip;
}

SystemColumnService.prototype.all = function () {
    return this.bip.get('/api/SystemColumns');
};
SystemColumnService.prototype.getAllForTable = function (tableId) {
    return this.bip.get('/api/SystemColumns/Table/' + tableId);
};
SystemColumnService.prototype.get = function (systemColumnId) {
    return this.bip.get('/api/SystemColumns/' + systemColumnId);
};

SystemColumnService.prototype.create = function (systemColumn) {
    return this.bip.post('/api/SystemColumns', systemColumn);
};

SystemColumnService.prototype.delete = function (systemColumnId) {
    return this.bip.delete('/api/SystemColumns/' + systemColumnId);
};

SystemColumnService.prototype.update = function (systemColumnId, systemColumn) {
    return this.bip.put('/api/SystemColumns/' + systemColumnId, systemColumn);
};

SystemColumnService.prototype.getColumnContracts = function () {
    return this.bip.get('/api/SystemColumnContracts');
};

SystemColumnService.prototype.getSystemValues = function (systemColumnId) {
    return this.bip.get('/api/SystemColumns/' + systemColumnId + '/Values');
};


function SystemValueService(bip) {
    this.bip = bip;
}

SystemValueService.prototype.all = function () {
    return this.bip.get('/api/SystemValues');
};

SystemValueService.prototype.get = function (systemValueId) {
    return this.bip.get('/api/SystemValues/' + systemValueId);
};

SystemValueService.prototype.create = function (systemValue) {
    return this.bip.post('/api/SystemValues', systemValue);
};

SystemValueService.prototype.delete = function (systemValueId) {
    return this.bip.delete('/api/SystemValues/' + systemValueId);
};

SystemValueService.prototype.update = function (systemValueId, systemValue) {
    return this.bip.put('/api/SystemValues/' + systemValueId, systemValue);
};

SystemValueService.prototype.getColumnValues = function (columnId, contractIds) {
    return this.bip.get('/api/SystemValues/ColumnValues/' + columnId + (contractIds ? '?' + $.param({ contractIds: contractIds }) : ''));
};

SystemValueService.prototype.setAsStandard = function (systemValueId, isStandard) {
    return this.bip.post('/api/SystemValues/Standard/' + systemValueId, isStandard, true);
};

SystemValueService.prototype.setAsAnomaly = function (systemValueId, isAnomaly) {
    return this.bip.post('/api/SystemValues/Anomaly/' + systemValueId, isAnomaly, true);
};

function ThemeService(bip) {
    this.bip = bip;
}

ThemeService.prototype.all = function () {
    return this.bip.get('/api/Themes');
};

ThemeService.prototype.create = function (theme) {
    return this.bip.post('/api/Themes', theme);
};

ThemeService.prototype.delete = function (themeId) {
    return this.bip.delete('/api/Themes/' + themeId);
};

ThemeService.prototype.get = function (themeId) {
    return this.bip.get('/api/Themes/' + themeId);
};

ThemeService.prototype.update = function (themeId, theme) {
    return this.bip.put('/api/Themes/' + themeId, theme);
};

ThemeService.prototype.getUserIds = function (themeId) {
    return this.bip.get('/api/Themes/' + themeId + '/Users');
};

ThemeService.prototype.tags = function () {
    return this.bip.get('/api/Themes/tags');
};
function UserGroupService(bip) {
    this.bip = bip;
}

UserGroupService.prototype.getUserIds = function (groupId) {
    return this.bip.get('/api/Groups/' + groupId + '/Users');
};

UserGroupService.prototype.getGroupIds = function (userId) {
    return this.bip.get('/api/Users/' + userId + '/Groups');
};

UserGroupService.prototype.addUser = function (groupId, userId) {
    return this.bip.post('/api/Groups/' + groupId + '/Users/' + userId);
};

UserGroupService.prototype.addGroup = function (userId, groupId) {
    return this.bip.post('/api/Users/' + userId + '/Groups/' + groupId);
};

UserGroupService.prototype.removeUser = function (groupId, userId) {
    return this.bip.delete('/api/Groups/' + groupId + '/Users/' + userId);
};

UserGroupService.prototype.removeGroup = function (userId, groupId) {
    return this.bip.delete('/api/Users/' + userId + '/Groups/' + groupId);
};

UserGroupService.prototype.removeAll = function (userId) {
    return this.bip.delete('/api/Groups/Remove/' + userId);
};
function UserService(bip) {
    this.bip = bip;
};

UserService.prototype.all = function () {
    return this.bip.get('/api/Users');
};

UserService.prototype.get = function (id) {
    return this.bip.get('/api/Users/' + id);
};

UserService.prototype.create = function (user) {
    return this.bip.post('/api/Users', user);
};

UserService.prototype.update = function (id, user) {
    return this.bip.put('/api/Users/' + id, user);
};

UserService.prototype.renewLastReview = function (id) {
    return this.bip.put('/api/Users/RenewLastReview/' +id);
};

UserService.prototype.verify = function (details) {
    return this.bip.put('/api/Users/Verify', details);
};

UserService.prototype.authenticate = function (details) {
    return this.bip.post('/api/Tokens', details);
};

UserService.prototype.loginAsOtherUser = function (userId) {
    return this.bip.get('/api/Tokens/' + userId);
};

UserService.prototype.getCurrent = function () {
    return this.bip.get('/api/Users/Current');
};

UserService.prototype.updatePassword = function (credentials) {
    return this.bip.put('/api/Users/Password', credentials);
};

UserService.prototype.resetPassword = function (userName) {
    return this.bip.put('/api/Users/ResetPassword?userName=' + encodeURIComponent(userName));
};

UserService.prototype.resetAccount = function (email) {
    return this.bip.put('/api/Users/' + email + '/ResetAccount');
};

UserService.prototype.linkToM5 = function (credentials) {
    return this.bip.put('/api/Users/M5', credentials);
};

UserService.prototype.getTheme = function () {
    return this.bip.get('/api/Users/Theme');
};

UserService.prototype.setCurrentTheme = function (themeId) {
    return this.bip.put('/api/Users/Theme/' + themeId);
};

UserService.prototype.setTheme = function (userId, themeId) {
    return this.bip.put('/api/Users/' + userId + '/Theme/' + themeId);
};

UserService.prototype.tags = function () {
    return this.bip.get('/api/Users/tags');
};

UserService.prototype.reactivateAccount = function (id) {
    return this.bip.put('/api/Users/' + id + '/Reactivate');
};

UserService.prototype.archive = function (id) {
    return this.bip.put('/api/Users/' + id + '/Archive');
};

UserService.prototype.allActive = function () {
    return this.bip.get('/api/Users/Active');
};
function EmailReportService(bip) {
    this.bip = bip;
}

EmailReportService.prototype.sendFijiReport = function (report) {
    return this.bip.post('/api/Email/Reports/Fiji', report, true);
};

EmailReportService.prototype.sendEmailReport = function (report) {
    return this.bip.post('/api/Email/Reports/Send', report, true);
};
function GeographyGeocodingService(bip) {
    this.bip = bip;
}

GeographyGeocodingService.prototype.reverseGeocode = function (lat, lng, address) {
    return this.bip.get(
        '/api/Geography/Geocoding/Reverse' +
        '?lat=' + lat +
        '&lng=' + lng +
        '&address=' + address);
};

GeographyGeocodingService.prototype.reverseGeocodeMulti = function (positions, address) {
    return this.bip.post(
        '/api/Geography/Geocoding/ReverseMulti' +
        '?address=' + address, positions, true);
};
function M5AssetService(bip) {
    this.bip = bip;
}

M5AssetService.prototype.getOpHourDurations = function (id, inputs, start, end) {
    parameters = { 'id': id, 'inputs': inputs, 'start': start, 'end': end };
    return this.bip.get('/api/M5Assets/OpHourDurations', parameters);
};

M5AssetService.prototype.getEroadOpHourDurations = function (id, start) {
    parameters = { 'id': id, 'start': start};
    return this.bip.get('/api/M5Assets/EroadOpHourDurations', parameters);
};

M5AssetService.prototype.getAssetLocation = function (assetId) {
    return this.bip.get('/api/M5Assets/AssetLocation/' + assetId);
};

M5AssetService.prototype.getLocations = function (groupIds, column) {
    return this.bip.post('/api/M5Assets/AssetLocations', groupIds, true);
};

M5AssetService.prototype.getLocationSnapshot = function (groupIds, column, dateTime) {
    return this.bip.post('/api/M5Assets/AssetLocationSnapshot?dateTimeUnix=' + Math.round(dateTime.getTime() / 1000), groupIds, true);
};

M5AssetService.prototype.all = function (groupIds) {
    return this.bip.post('/api/M5Assets',groupIds, true);
};

M5AssetService.prototype.allAssetTypes = function () {
    return this.bip.get('/api/M5Assets/AssetTypes');
};

M5AssetService.prototype.allAssetInGroups = function () {
    return this.bip.get('/api/M5Assets/AssetInGroups');
};

M5AssetService.prototype.listPropertyKeys = function () {
    return this.bip.get('/api/M5Assets/ListPropertyKeys');
};

M5AssetService.prototype.listPropertyValues = function (propertyKey) {
    return this.bip.get('/api/M5Assets/ListPropertyValues?propertyKey=' + propertyKey);
};

M5AssetService.prototype.listAnalogInputDefinitions = function (assetTypeId) {
    return this.bip.get('/api/M5Assets/AnalogInputDefinitions' + (assetTypeId ? '?assetTypeId=' + assetTypeId : ''));
};

M5AssetService.prototype.listDigitalInputDefinitions = function (assetTypeId) {
    return this.bip.get('/api/M5Assets/DigitalInputDefinitions' + (assetTypeId ? '?assetTypeId=' + assetTypeId : ''));
};

M5AssetService.prototype.listCounterInputDefinitions = function (assetTypeId) {
    return this.bip.get('/api/M5Assets/CounterInputDefinitions' + (assetTypeId ? '?assetTypeId=' + assetTypeId : ''));
};

M5AssetService.prototype.trackerConfigurations = function () {
    return this.bip.get('/api/M5Assets/trackerConfigurations');
};

M5AssetService.prototype.getInputs = function (assetTypeId) {
    return this.bip.get('/api/M5Assets/CounterInputDefinitions?assetTypeId=' + assetTypeId);
};

M5AssetService.prototype.getCurrentAnalogInputValues = function (id, inputNumbers) {
    return this.bip.get('/api/M5Assets/' + id + '/CurrentAnalogInputValues' + inputNumbers.reduce(function (a, b, i) { return a + (i === 0 ? '?' : '&') + 'inputNumbers=' + b; }, ''));
};

M5AssetService.prototype.getCurrentDigitalInputValues = function (id, inputNumbers) {
    return this.bip.get('/api/M5Assets/' + id + '/CurrentDigitalInputValues' + inputNumbers.reduce(function (a, b, i) { return a + (i === 0 ? '?' : '&') + 'inputNumbers=' + b; }, ''));
};

M5AssetService.prototype.getCurrentCounterInputValues = function (id, inputNumbers) {
    return this.bip.get('/api/M5Assets/' + id + '/CurrentCounterInputValues' + inputNumbers.reduce(function (a, b, i) { return a + (i === 0 ? '?' : '&') + 'inputNumbers=' + b; }, ''));
};

M5AssetService.prototype.getReadings = function (machineryId, options) {
    var url = '/api/M5Assets/' + machineryId + '/Readings';
    var parameters = [];

    if (options.start) {
        var start = options.start;
        parameters.push({ key: 'start', value: Math.round(start.getTime() / 1000) });
    }

    if (options.end) {
        var end = options.end;
        parameters.push({ key: 'end', value: Math.round(options.end.getTime() / 1000) });
    }

    if (options.isEroads) {
        parameters.push({ key: 'isEroads', value: options.isEroads });
    }

    if (parameters.length > 0) {
        url += '?' + parameters.map(function (p) { return p.key + '=' + p.value; }).join('&');
    }

    return this.bip.get(url);
};

M5AssetService.prototype.getGroupedReadings = function (machineryId, options) {
    var url = '/api/M5Assets/' + machineryId + '/Readings/Grouped';
    var parameters = [];

    if (options.start) {
        var start = options.start;
        parameters.push({ key: 'start', value: Math.round(start.getTime() / 1000) });
    }

    if (options.end) {
        var end = options.end;
        parameters.push({ key: 'end', value: Math.round(options.end.getTime() / 1000) });
    }

    if (parameters.length > 0) {
        url += '?' + parameters.map(function (p) { return p.key + '=' + p.value; }).join('&');
    }

    return this.bip.get(url);
};

M5AssetService.prototype.getAssetsInArea = function (groupIds, points, start, end) {
    var url = '/api/M5Assets/AssetsInArea';
    var parameters = [];

    points.forEach(function (point, i) {
        parameters.push({ key: 'points[' + i + '].X', value: point[0] });
        parameters.push({ key: 'points[' + i + '].Y', value: point[1] });
    });

    if (start) {
        parameters.push({ key: 'start', value: Math.round(start.getTime() / 1000) });
    }

    if (end) {
        parameters.push({ key: 'end', value: Math.round(end.getTime() / 1000) });
    }

    if (parameters.length > 0) {
        url += '?' + parameters.map(function (p) { return p.key + '=' + p.value; }).join('&');
    }

    return this.bip.post(url, groupIds, true);
};

M5AssetService.prototype.getCoverageData = function () {
    return this.bip.get('/api/M5Assets/Coverage');
};

M5AssetService.prototype.getCoverageDataAtLatLng = function (lat, lng) {
    return this.bip.get('/api/M5Assets/Coverage?lat=' + lat + '&lng=' + lng);
};

M5AssetService.prototype.getFunctionRange = function (deviceId, columns, inputNumbers, analogDefinitonIds, digitalDefinitionIds, counterDefinitionIds, start, end) {
    return this.bip.get(
        '/api/M5Assets/' + deviceId +
        '/Function' +
        '?start=' + start.getTime() +
        '&end=' + end.getTime() +
        columns.reduce(function (a, b) { return a + '&columns=' + b; }, '') +
        inputNumbers.reduce(function (a, b) { return a + '&functionDigitalInputNumbers=' + b; }, '') +
        analogDefinitonIds.reduce(function (a, b) { return a + '&analogInputDefinitionIds=' + b; }, '') +
        digitalDefinitionIds.reduce(function (a, b) { return a + '&digitalInputDefinitionIds=' + b; }, '') +
        counterDefinitionIds.reduce(function (a, b) { return a + '&counterInputDefinitionIds=' + b; }, ''));
};


function M5GroupPermissionService(bip) {
    this.bip = bip;
}

M5GroupPermissionService.prototype.all = function () {
    return this.bip.get('/api/M5GroupPermissions');
};

M5GroupPermissionService.prototype.get = function (wfsGroupSourcePermissionId) {
    return this.bip.get('/api/M5GroupPermissions/' + wfsGroupSourcePermissionId);
};

M5GroupPermissionService.prototype.getByGroupM5Group = function (groupId, m5GroupId) {
    return this.bip.get('/api/Groups/' + groupId + '/M5Groups/' + m5GroupId + '/M5GroupPermissions');
};

M5GroupPermissionService.prototype.create = function (wfsGroupSourcePermission) {
    return this.bip.post('/api/M5GroupPermissions', wfsGroupSourcePermission);
};

M5GroupPermissionService.prototype.delete = function (wfsGroupSourcePermissionId) {
    return this.bip.delete('/api/M5GroupPermissions/' + wfsGroupSourcePermissionId);
};

M5GroupPermissionService.prototype.update = function (wfsGroupSourcePermissionId, wfsGroupSourcePermission) {
    return this.bip.put('/api/M5GroupPermissions/' + wfsGroupSourcePermissionId, wfsGroupSourcePermission);
}; 

M5GroupPermissionService.prototype.allGroup = function (groupID) {
    return this.bip.get('/api/M5GroupPermissions/Group/' + groupID);
}; 
function M5GroupService(bip) {
    this.bip = bip;
}

M5GroupService.prototype.all = function () {
    return this.bip.get('/api/M5Groups');
};
function LocatorBeaconNotificationService(bip) {
    this.bip = bip;
}

LocatorBeaconNotificationService.prototype.get = function () {
    return this.bip.get('/api/LocatorBeaconNotifications/Check');
};

LocatorBeaconNotificationService.prototype.all = function () {
    return this.bip.get('/api/LocatorBeaconNotifications');
};

LocatorBeaconNotificationService.prototype.update = function (locatorBeaconNotification) {
    return this.bip.put('/api/LocatorBeaconNotifications/', locatorBeaconNotification);
};

LocatorBeaconNotificationService.prototype.action = function (locatorBeaconNotification) {
    return this.bip.put('/api/LocatorBeaconNotifications/Action', locatorBeaconNotification);
};
function M5TrackerService(bip) {
    this.bip = bip;
}

M5TrackerService.prototype.getTrackerConfigurations = function () {
    return this.bip.get('/api/M5Trackers/Configurations');
};
function RammAuthenticationService(bip) {
    this.bip = bip;
}

RammAuthenticationService.prototype.getDatabases = function (username, password) {
    return this.bip.post('/api/RammAuthentication', { UserName: username, Password: password });
};

RammAuthenticationService.prototype.getDatabasesNoAuth = function () {
    return this.bip.get('/api/RammAuthentication');
};
function RammBudgetingService(bip) {
    this.bip = bip;
}

RammBudgetingService.prototype.get = function (contract, programmeIds) {
    return this.bip.get('/api/Ramm/Budgeting?rammDatabase=' + encodeURIComponent(contract.database || contract.Database) + "&contractId=" + encodeURIComponent(contract.value || contract.RammID) + "&programmeIds=" + programmeIds, true);
};
RammBudgetingService.prototype.getYear = function (contract, code) {
    return this.bip.get('/api/Ramm/Budgeting/Year?rammDatabase=' + encodeURIComponent(contract.database || contract.Database) + "&contractId=" + encodeURIComponent(contract.value || contract.RammID) + "&code=" + code, true);
};
RammBudgetingService.prototype.getAccountCodes = function (contract) {
    return this.bip.get('/api/Ramm/Budgeting/AccountCodes?rammDatabase=' + encodeURIComponent(contract.database || contract.Database) + "&contractId=" + encodeURIComponent(contract.value || contract.RammID), true);
};
function RammDeviceFunctionService(bip) {
    this.bip = bip;
}

RammDeviceFunctionService.prototype.getRange = function (deviceId, groupId, columns, start, end) {
    return this.bip.get('/api/Ramm/Devices/' + deviceId + '/Function/' + groupId + '?start=' + start.getTime() + '&end=' + end.getTime() + columns.reduce(function (a, b) { return a + '&columns=' + b; }, ''));
};
function RammDispatchService(bip) {
    this.bip = bip;
}

RammDispatchService.prototype.search = function (contract, filters) {
    return this.bip.post('/api/Ramm/Dispatches/Search?rammDatabase=' + encodeURIComponent(contract.database || contract.Database) + "&contractId=" + encodeURIComponent(contract.value || contract.RammID), filters, true);
};

RammDispatchService.prototype.columns = function (database, contract) {
    return this.bip.get('/api/Ramm/Dispatches/UpdateColumnsFromRamm?rammDatabase=' + encodeURIComponent(database) + "&contract="+encodeURIComponent(contract));
};

RammDispatchService.prototype.columnValues = function (contract, column, assetTypeIds) {
    return this.bip.post('/api/Ramm/Dispatches/GetColumnValues?rammDatabase=' + encodeURIComponent(contract.Database) + '&contract=' + encodeURIComponent(contract.RammID), { Column: column, AssetTypeIDs: assetTypeIds });
};

RammDispatchService.prototype.update = function (database, entityId, updateList) {
    return this.bip.put('/api/Ramm/Dispatches/Update?rammDatabase=' + encodeURIComponent(database) + '/' + encodeURI(entityId), updateList);
}

RammDispatchService.prototype.bulkUpdate = function (credentials, dispatchDetails, newValues) {
    return this.bip.post('/api/Ramm/Dispatches/Update?' + $.param(credentials) + '&' + $.param(dispatchDetails), newValues, true);
}
function RammEntityService(bip) {
    this.bip = bip;
}

RammEntityService.prototype.get = function (database, entityId) {
    return this.bip.get('/api/Ramm/Entity?rammDatabase=' + encodeURIComponent(database) + '&entityId=' + entityId);
};

RammEntityService.prototype.getWithOptions = function (database, entityRequest) {
    return this.bip.post('/api/Ramm/Entity?rammDatabase=' + encodeURIComponent(database), entityRequest, true);
};

RammEntityService.prototype.update = function (database, entityUpdateModel) {
    return this.bip.post('/api/Ramm/Entity/Update?rammDatabase=' + encodeURIComponent(database), entityUpdateModel, true);
};
function RammGeometryAttributesService(bip) {
    this.bip = bip;
}

RammGeometryAttributesService.prototype.getCloseRoads = function (database, geometry) {
    return this.bip.get('/api/Ramm/GeometryAttributes/CloseRoads?geometryWKT=' + encodeURIComponent(geometry) + '&rammDatabase=' + encodeURIComponent(database));
};

RammGeometryAttributesService.prototype.getClosestRoad = function (database, geometry) {
    return this.bip.get('/api/Ramm/GeometryAttributes/ClosestRoad?geometryWKT=' + encodeURIComponent(geometry) + '&rammDatabase=' + encodeURIComponent(database));
};


RammGeometryAttributesService.prototype.getLocationInformation = function (database, tableName, roadId, geometry) {
    return this.bip.get('/api/Ramm/GeometryAttributes/LocationInformation?tableName=' + encodeURIComponent(tableName) + '&roadId=' + encodeURIComponent(roadId) + '&geometryWKT=' + encodeURIComponent(geometry) + '&rammDatabase=' + encodeURIComponent(database));
};

RammGeometryAttributesService.prototype.getCarriageWayAttribute = function (database, roadId, start_m, end_m, columnName) {
    return this.bip.get('/api/Ramm/GeometryAttributes/CarriageWayAttribute?roadId=' + encodeURIComponent(roadId) + '&start_m=' + encodeURIComponent(start_m) + '&end_m=' + encodeURIComponent(end_m) + '&columnName=' + encodeURIComponent(columnName) + '&rammDatabase=' + encodeURIComponent(database));
};

RammGeometryAttributesService.prototype.getFormAttributes = function (database, geometry, attributes) {
    return this.bip.get('/api/Ramm/GeometryAttributes/GetFormAttributes?geometryWKT=' + encodeURIComponent(geometry) + '&rammDatabase=' + encodeURIComponent(database) + '&' + $.param({ attributes: attributes }));
};
function RammGroupLayerPermissionService(bip) {
    this.bip = bip;
}

RammGroupLayerPermissionService.prototype.all = function () {
    return this.bip.get('/api/RammGroupLayerPermissions');
};

RammGroupLayerPermissionService.prototype.get = function (wfsGroupSourcePermissionId) {
    return this.bip.get('/api/RammGroupLayerPermissions/' + wfsGroupSourcePermissionId);
};

RammGroupLayerPermissionService.prototype.getByGroupLayer = function (groupId, layerId) {
    return this.bip.get('/api/Groups/' + groupId + '/Layers/' + layerId + '/RammGroupLayerPermissions');
};

RammGroupLayerPermissionService.prototype.create = function (wfsGroupSourcePermission) {
    return this.bip.post('/api/RammGroupLayerPermissions', wfsGroupSourcePermission);
};

RammGroupLayerPermissionService.prototype.delete = function (wfsGroupSourcePermissionId) {
    return this.bip.delete('/api/RammGroupLayerPermissions/' + wfsGroupSourcePermissionId);
};

RammGroupLayerPermissionService.prototype.update = function (wfsGroupSourcePermissionId, wfsGroupSourcePermission) {
    return this.bip.put('/api/RammGroupLayerPermissions/' + wfsGroupSourcePermissionId, wfsGroupSourcePermission);
};

RammGroupLayerPermissionService.prototype.allGroup = function (groupID) {
    return this.bip.get('/api/RammGroupLayerPermissions/Group/' + groupID);
}; 
//TODO: Should have a service for each different table, instead of doing it this way

function RammLookupService(bip) {
    this.bip = bip;
}

RammLookupService.prototype.get = function (endpoint, database) {
    return this.bip.get('/api/Ramm/' + endpoint + '/Lookup?rammDatabase=' + encodeURIComponent(database));
};

RammLookupService.prototype.get = function (endpoint, database, contracts, assetTypes) {
    return this.bip.get('/api/Ramm/' + endpoint + '/Lookup?rammDatabase=' + encodeURIComponent(database) + '&contractIds=' + encodeURIComponent(contracts) + '&assetTypeIds=' + encodeURIComponent(assetTypes) );
};

RammLookupService.prototype.getGeneric = function (database, table, idColumn, descColumn ) {
    return this.bip.get('/api/Ramm/Lookup?rammDatabase=' + encodeURIComponent(database) + '&table=' + encodeURIComponent(table) + '&idColumn=' + encodeURIComponent(idColumn) + '&descColumn=' + encodeURIComponent(descColumn));
};

RammLookupService.prototype.getColumnLookups = function (database, table, column) {
    return this.bip.get('/api/Ramm/LookupColumn?rammDatabase=' + encodeURIComponent(database) + '&table=' + encodeURIComponent(table) + '&column=' + encodeURIComponent(column));
};
function RammMetaService(bip) {
    this.bip = bip;
}
RammMetaService.prototype.databases = function () {
    return this.bip.get('/api/Ramm/Databases');
};
RammMetaService.prototype.tables = function (database) {
    return this.bip.get('/api/Ramm/Meta/Tables?rammDatabase=' + encodeURIComponent(database));
};

RammMetaService.prototype.columns = function (database, table) {
    return this.bip.get('/api/Ramm/Meta/Columns?rammDatabase=' + encodeURIComponent(database) + '&table=' + encodeURIComponent(table));
};

RammMetaService.prototype.lookup = function (database, table, column) {
    return this.bip.get('/api/Ramm/Meta/Lookup' +
        '?rammDatabase=' + encodeURIComponent(database) +
        '&table=' + encodeURIComponent(table) +
        '&column=' + encodeURIComponent(column));
};


RammMetaService.prototype.udtList = function () {
    return this.bip.get('api/Ramm/Meta/UdtList');
};


RammMetaService.prototype.columnsCompare = function (tableName) {
    return this.bip.get('api/Ramm/Meta/ColumnsCompare?tableName=' + tableName);
};
function RammMultimediaService(bip) {
    this.bip = bip;
}

RammMultimediaService.prototype.get = function (database, entityId) {
    return this.bip.get('/api/Ramm/Multimedia/Items/' + entityId+'?rammDatabase=' + encodeURIComponent(database));
};

RammMultimediaService.prototype.upload = function (database, entityId, multimedia) {
    var data = new FormData();
    data.append('file', multimedia, multimedia.name);
    return this.bip.upload('/api/Ramm/Multimedia/Upload/' + entityId + '?rammDatabase=' + encodeURIComponent(database)+'&fileName=test.jpg', 'multipart/form-data', data);
};

RammMultimediaService.prototype.delete = function (database, multimediaId) {
    return this.bip.delete('/api/Ramm/Multimedia/Delete/' + multimediaId + '?rammDatabase=' + encodeURIComponent(database));
};
function RammProgrammeService(bip) {
    this.bip = bip;
}

RammProgrammeService.prototype.get = function (database) {
    return this.bip.get('/api/Ramm/Programmes/Lookup?rammDatabase=' + encodeURIComponent(database));
};

RammProgrammeService.prototype.getDates = function (contract) {
    return this.bip.get('/api/Ramm/Programmes/Dates?rammDatabase=' + encodeURIComponent(contract.Database) + "&contractId=" + encodeURIComponent(contract.RammID));
};
function RammProgressNotesService(bip) {
    this.bip = bip;
}

RammProgressNotesService.prototype.get = function (database, filters) {
    return this.bip.post('/api/Ramm/ProgressNotes?rammDatabase=' + encodeURIComponent(database), filters, true);
};
//TODO: Should have a service for each different table, instead of doing it this way

function RammContractService(bip) {
    this.bip = bip;
}

RammContractService.prototype.get = function (database) {
    return this.bip.get('/api/Ramm/Contracts/Lookup?rammDatabase=' + encodeURIComponent(database));
};

RammContractService.prototype.updateFromRamm = function (databases) {
    return this.bip.post('/api/Ramm/Contracts/UpdateFromRamm', databases);
};
function TableLinkageService(bip) {
    this.bip = bip;
}



TableLinkageService.prototype.columns = function (table, database, contract) {
    return this.bip.get('/api/Ramm/TableLinkage/' + table.ID +'/UpdateColumnsFromRamm/?rammDatabase=' + encodeURIComponent(database) + "&contract="+encodeURIComponent(contract));
};

TableLinkageService.prototype.columnValues = function (table, contract, column, assetTypeIds) {
    return this.bip.post('/api/Ramm/TableLinkage/'+table.ID +'/GetColumnValues?rammDatabase=' + encodeURIComponent(contract.Database) + '&contract=' + encodeURIComponent(contract.RammID), { Column: column, AssetTypeIDs: assetTypeIds });
};

TableLinkageService.prototype.matchColumn = function (tableId, columnId) {
    return this.bip.get('api/Ramm/TableLinkage/' + tableId + '/MatchColumn/' +columnId)
}

TableLinkageService.prototype.matchColumns = function (tableId) {
    return this.bip.get('api/Ramm/TableLinkage/MatchColumns' + (tableId ? '/' + tableId : ''));
}



function RammTableService(bip) {
    this.bip = bip;
}

RammTableService.prototype.getData = function (database, table, columns, filters, getGeometry, sorting) {
    return this.bip.post('/api/Ramm/Table?rammDatabase=' + encodeURIComponent(database), { 'TableName': table, 'Columns': columns, 'Filters': filters, 'GridSorting': sorting, 'GetGeometry': getGeometry === false ? false : true }, true);
};

RammTableService.prototype.add = function (database, table, data) {
    return this.bip.post('/api/Ramm/Table/Add?rammDatabase=' + encodeURIComponent(database) + '&table=' + encodeURIComponent(table), data, true);
};
function RammProxyConfigService(bip) {
    this.bip = bip;
}

RammProxyConfigService.prototype.getActive = function () {
    return this.bip.get('api/RammProxy/Config/active');
};
RammProxyConfigService.prototype.setActive = function (enabled) {
    return this.bip.post('api/RammProxy/Config/active',enabled);
};

RammProxyConfigService.prototype.initialSetup = function (options) {
    var uri = 'api/RammProxy/Config/setup';
    var params = "";
    params += options.databaseId ? '?databaseId=' + options.databaseId : '';
    params += options.databaseDescription ? (params ? '&' : '?') + 'databaseDescription=' + options.databaseDescription : '';
    params += options.addTables ? (params ? '&' : '?') + 'addTables=' + options.addTables : '';
    params += options.updateTables ? (params ? '&' : '?') + 'updateTables=' + options.updateTables : '';
    return this.bip.get(uri + params);
};

RammProxyConfigService.prototype.setCaching = function (table, cacheTable, cacheLookups) {
    return this.bip.get('api/RammProxy/Config/cache/' + table + '?cacheTable=' + cacheTable + '&cacheLookups=' + cacheLookups);
};

RammProxyConfigService.prototype.updateCache = function (table) {
    return this.bip.get('api/RammProxy/Config/cache/' + table + '/refresh');
};

RammProxyConfigService.prototype.setLogin = function (credentials) {
    return this.bip.post('api/RammProxy/Config/logindetails', credentials, true);
};

RammProxyConfigService.prototype.getLogin = function () {
    return this.bip.get('api/RammProxy/Config/logindetails');
};

RammProxyConfigService.prototype.getTables = function () {
    return this.bip.get('api/RammProxy/Config/tables');
};

RammProxyConfigService.prototype.getDatabases = function () {
    return this.bip.get('api/RammProxy/Config/databases');
};
function TableauTicketService(bip) {
    this.bip = bip;
}

TableauTicketService.prototype.get = function () {
    return this.bip.get('/api/Tableau/Ticket');
};
function WfsGroupSourcePermissionService(bip) {
    this.bip = bip;
}

WfsGroupSourcePermissionService.prototype.all = function () {
    return this.bip.get('/api/WfsGroupSourcePermissions');
};

WfsGroupSourcePermissionService.prototype.getBySourceAndLayer = function (layerId, sourceId) {
    return this.bip.get('/api/WfsGroupSourcePermissions/layer/'+layerId+'/source/'+sourceId);
};

WfsGroupSourcePermissionService.prototype.get = function (wfsGroupSourcePermissionId) {
    return this.bip.get('/api/WfsGroupSourcePermissions/' + wfsGroupSourcePermissionId);
};
WfsGroupSourcePermissionService.prototype.getByGroupSource = function (groupId, sourceId) {
    return this.bip.get('/api/Groups/' + groupId + '/Sources/' + sourceId + '/WfsGroupSourcePermissions');
};

WfsGroupSourcePermissionService.prototype.create = function (wfsGroupSourcePermission) {
    return this.bip.post('/api/WfsGroupSourcePermissions', wfsGroupSourcePermission);
};

WfsGroupSourcePermissionService.prototype.delete = function (wfsGroupSourcePermissionId) {
    return this.bip.delete('/api/WfsGroupSourcePermissions/' + wfsGroupSourcePermissionId);
};

WfsGroupSourcePermissionService.prototype.update = function (wfsGroupSourcePermissionId, wfsGroupSourcePermission) {
    return this.bip.put('/api/WfsGroupSourcePermissions/' + wfsGroupSourcePermissionId, wfsGroupSourcePermission);
}; 

WfsGroupSourcePermissionService.prototype.allGroup = function (groupID) {
    return this.bip.get('/api/WfsGroupSourcePermissions/Group/' + groupID);    
}