tango-app-api-store-builder 1.0.2-alpha → 1.0.2

package/src/service/fixtureConfigDuplicate.service.js

@@ -0,0 +1,52 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.fixtureConfigDulicateModel.find( query, field );
+}
+
+export async function findOne( query={}, field={} ) {
+  return model.fixtureConfigDulicateModel.findOne( query, field );
+}
+
+export async function insertMany( data = [] ) {
+  return model.fixtureConfigDulicateModel.insertMany( data );
+}
+
+export async function aggregate( query = [] ) {
+  return model.fixtureConfigDulicateModel.aggregate( query, { collation: { locale: 'en_US', numericOrdering: true } } );
+}
+
+export async function updateOne( query = {}, record = {} ) {
+  return model.fixtureConfigDulicateModel.updateOne( query, { $set: record } );
+}
+
+export async function count( query = {} ) {
+  return model.fixtureConfigDulicateModel.countDocuments( query );
+}
+
+export async function upsertOne( query, record ) {
+  return model.fixtureConfigDulicateModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+export async function create( data = {} ) {
+  return model.fixtureConfigDulicateModel.create( data );
+}
+
+export async function deleteOne( query = {} ) {
+  return model.fixtureConfigDulicateModel.deleteOne( query );
+}
+
+export const findAndSort = async ( query={}, field={}, sort={} ) => {
+  return await model.fixtureConfigDulicateModel.find( query, field ).sort( sort ).collation( { locale: 'en_US', numericOrdering: true } );
+};
+
+export const sortAndFindOne = async ( query={}, field={}, sort={} ) => {
+  return await model.fixtureConfigDulicateModel.find( query, field ).sort( sort ).limit( 1 );
+};
+
+export async function updateMany( query = {}, record = {} ) {
+  return model.fixtureConfigDulicateModel.updateMany( query, { $set: record } );
+}

package/src/service/fixtureShelf.service.js

@@ -0,0 +1,53 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.fixtureShelfModel.find( query, field );
+}
+
+export async function findAndSort( query={}, field={}, sortField={} ) {
+  return model.fixtureShelfModel.find( query, field ).sort( sortField );
+}
+
+export async function findOne( query={}, field={} ) {
+  return model.fixtureShelfModel.findOne( query, field );
+}
+
+export async function insertMany( data ) {
+  return model.fixtureShelfModel.insertMany( data );
+}
+
+export async function aggregate( query ) {
+  return model.fixtureShelfModel.aggregate( query );
+}
+
+export async function updateOne( query, record ) {
+  return model.fixtureShelfModel.updateOne( query, { $set: record } );
+}
+
+export async function create( data ) {
+  return model.fixtureShelfModel.create( data );
+}
+
+export async function count( data ) {
+  return model.fixtureShelfModel.countDocuments( data );
+}
+
+export async function deleteOne( query ) {
+  return model.fixtureShelfModel.deleteOne( query );
+}
+
+export async function deleteMany( query ) {
+  return model.fixtureShelfModel.deleteMany( query );
+}
+
+export async function upsertOne( query, record ) {
+  return model.fixtureShelfModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+
+export async function updateMany( query, record ) {
+  return model.fixtureShelfModel.updateMany( query, { $set: record } );
+}

package/src/service/fixtureShelfDuplicate.service.js

@@ -0,0 +1,53 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.fixtureShelfDuplicateModel.find( query, field );
+}
+
+export async function findAndSort( query={}, field={}, sortField={} ) {
+  return model.fixtureShelfDuplicateModel.find( query, field ).sort( sortField );
+}
+
+export async function findOne( query={}, field={} ) {
+  return model.fixtureShelfDuplicateModel.findOne( query, field );
+}
+
+export async function insertMany( data ) {
+  return model.fixtureShelfDuplicateModel.insertMany( data );
+}
+
+export async function aggregate( query ) {
+  return model.fixtureShelfDuplicateModel.aggregate( query );
+}
+
+export async function updateOne( query, record ) {
+  return model.fixtureShelfDuplicateModel.updateOne( query, { $set: record } );
+}
+
+export async function create( data ) {
+  return model.fixtureShelfDuplicateModel.create( data );
+}
+
+export async function count( data ) {
+  return model.fixtureShelfDuplicateModel.countDocuments( data );
+}
+
+export async function deleteOne( query ) {
+  return model.fixtureShelfDuplicateModel.deleteOne( query );
+}
+
+export async function deleteMany( query ) {
+  return model.fixtureShelfDuplicateModel.deleteMany( query );
+}
+
+export async function upsertOne( query, record ) {
+  return model.fixtureShelfDuplicateModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+
+export async function updateMany( query, record ) {
+  return model.fixtureShelfDuplicateModel.updateMany( query, { $set: record } );
+}

package/src/service/planoCompliance.service.js

@@ -0,0 +1,33 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.planoComplianceModel.find( query, field );
+}
+
+export async function findOne( query={}, field={} ) {
+  return model.planoComplianceModel.findOne( query, field );
+}
+
+export async function insertMany( data ) {
+  return model.planoComplianceModel.insertMany( data );
+}
+
+export async function create( data ) {
+  return model.planoComplianceModel.create( data );
+}
+
+export async function aggregate( query ) {
+  return model.planoComplianceModel.aggregate( query );
+}
+
+export async function updateOne( query, record ) {
+  return model.planoComplianceModel.updateOne( query, { $set: record }, { upsert: true } );
+}
+
+export async function count( data ) {
+  return model.planoComplianceModel.countDocuments( data );
+}
+
+export async function findLean( query={}, field={} ) {
+  return model.planoComplianceModel.findOne( query, field ).lean();
+}

package/src/service/planoDuplicateModel.service.js

@@ -0,0 +1,41 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.planoDuplicateModel.find( query, field );
+}
+
+export async function findOne( query={}, field={} ) {
+  return model.planoDuplicateModel.findOne( query, field );
+}
+
+export async function insertMany( data ) {
+  return model.planoDuplicateModel.insertMany( data );
+}
+
+export async function aggregate( query ) {
+  return model.planoDuplicateModel.aggregate( query );
+}
+
+export async function updateOne( query, record ) {
+  return model.planoDuplicateModel.updateOne( query, record );
+}
+
+export async function updateMany( query, record ) {
+  return model.planoDuplicateModel.updateMany( query, { $set: record } );
+}
+
+export async function deleteOne( query ) {
+  return model.planoDuplicateModel.deleteOne( query );
+}
+
+export async function upsertOne( query, record ) {
+  return model.planoDuplicateModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+
+export async function create( data ) {
+  return model.planoDuplicateModel.create( data );
+}

package/src/service/planoGlobalComment.service.js

@@ -0,0 +1,25 @@
+import model from 'tango-api-schema';
+
+export async function create( data ) {
+  return model.planoGlobalComment.create( data );
+}
+
+export async function findOne( query = {}, field = {} ) {
+  return model.planoGlobalComment.findOne( query, field );
+}
+
+export async function updateOne( query = {}, record = {} ) {
+  return model.planoGlobalComment.updateOne( query, { $set: record }, { upsert: true } );
+}
+
+export async function deleteMany( query = {} ) {
+  return model.planoGlobalComment.deleteMany( query );
+}
+
+export async function aggregate( query = {} ) {
+  return model.planoGlobalComment.aggregate( query );
+}
+
+export async function find( query = {}, field = {} ) {
+  return model.planoGlobalComment.find( query, field );
+}

package/src/service/planoLibrary.service.js

@@ -0,0 +1,45 @@
+import model from 'tango-api-schema';
+
+export const findOne = async ( query={}, field={} ) => {
+  return await model.fixtureLibraryModel.findOne( query, field );
+};
+
+export const findAndSort = async ( query={}, field={}, sort={} ) => {
+  return await model.fixtureLibraryModel.find( query, field ).sort( sort ).collation( { locale: 'en_US', numericOrdering: true } );
+};
+
+export const find = async ( query={}, field={} ) => {
+  return await model.fixtureLibraryModel.find( query, field );
+};
+
+export const updateOne = async ( query={}, record={} ) => {
+  return await model.fixtureLibraryModel.updateOne( query, { $set: record } );
+};
+
+export const deleteOne = async ( query={} ) => {
+  return await model.fixtureLibraryModel.deleteOne( query );
+};
+
+export const insertMany = async ( data = [] ) => {
+  return await model.fixtureLibraryModel.insertMany( data );
+};
+
+export const deleteMany = async ( data = [] ) => {
+  return await model.fixtureLibraryModel.deleteMany( data );
+};
+
+export const create = async ( data = {} ) => {
+  return await model.fixtureLibraryModel.create( data );
+};
+
+export const aggregate = async ( query=[] ) => {
+  return await model.fixtureLibraryModel.aggregate( query );
+};
+
+export async function upsertOne( query, record ) {
+  return model.fixtureLibraryModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}

package/src/service/planoLibraryDuplicate.service.js

@@ -0,0 +1,45 @@
+import model from 'tango-api-schema';
+
+export const findOne = async ( query={}, field={} ) => {
+  return await model.fixtureLibraryDuplicateModel.findOne( query, field );
+};
+
+export const findAndSort = async ( query={}, field={}, sort={} ) => {
+  return await model.fixtureLibraryDuplicateModel.find( query, field ).sort( sort ).collation( { locale: 'en_US', numericOrdering: true } );
+};
+
+export const find = async ( query={}, field={} ) => {
+  return await model.fixtureLibraryDuplicateModel.find( query, field );
+};
+
+export const updateOne = async ( query={}, record={} ) => {
+  return await model.fixtureLibraryDuplicateModel.updateOne( query, { $set: record } );
+};
+
+export const deleteOne = async ( query={} ) => {
+  return await model.fixtureLibraryDuplicateModel.deleteOne( query );
+};
+
+export const insertMany = async ( data = [] ) => {
+  return await model.fixtureLibraryDuplicateModel.insertMany( data );
+};
+
+export const deleteMany = async ( data = [] ) => {
+  return await model.fixtureLibraryDuplicateModel.deleteMany( data );
+};
+
+export const create = async ( data = {} ) => {
+  return await model.fixtureLibraryDuplicateModel.create( data );
+};
+
+export const aggregate = async ( query=[] ) => {
+  return await model.fixtureLibraryDuplicateModel.aggregate( query );
+};
+
+export async function upsertOne( query, record ) {
+  return model.fixtureLibraryDuplicateModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}

package/src/service/planoMapping.service.js

@@ -0,0 +1,44 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.planoMappingModel.find( query, field );
+}
+export async function findOne( query={}, field={} ) {
+  return model.planoMappingModel.findOne( query, field );
+}
+
+export async function insertMany( data ) {
+  return model.planoMappingModel.insertMany( data );
+}
+
+export async function aggregate( query ) {
+  return model.planoMappingModel.aggregate( query );
+}
+
+export async function updateOne( query, record ) {
+  return model.planoMappingModel.updateOne( query, { $set: record } );
+}
+
+export async function count( query ) {
+  return model.planoMappingModel.countDocuments( query );
+}
+
+export async function create( data ) {
+  return model.planoMappingModel.create( data );
+}
+
+export async function deleteOne( query ) {
+  return model.planoMappingModel.deleteOne( query );
+}
+
+export async function deleteMany( query ) {
+  return model.planoMappingModel.deleteMany( query );
+}
+
+export async function upsertOne( query, record ) {
+  return model.planoMappingModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}

package/src/service/planoMappingDuplicate.service.js

@@ -0,0 +1,44 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.planoMappingDuplicateModel.find( query, field );
+}
+export async function findOne( query={}, field={} ) {
+  return model.planoMappingDuplicateModel.findOne( query, field );
+}
+
+export async function insertMany( data ) {
+  return model.planoMappingDuplicateModel.insertMany( data );
+}
+
+export async function aggregate( query ) {
+  return model.planoMappingDuplicateModel.aggregate( query );
+}
+
+export async function updateOne( query, record ) {
+  return model.planoMappingDuplicateModel.updateOne( query, { $set: record } );
+}
+
+export async function count( query ) {
+  return model.planoMappingDuplicateModel.countDocuments( query );
+}
+
+export async function create( data ) {
+  return model.planoMappingDuplicateModel.create( data );
+}
+
+export async function deleteOne( query ) {
+  return model.planoMappingDuplicateModel.deleteOne( query );
+}
+
+export async function deleteMany( query ) {
+  return model.planoMappingDuplicateModel.deleteMany( query );
+}
+
+export async function upsertOne( query, record ) {
+  return model.planoMappingDuplicateModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}

package/src/service/planoProduct.service.js

@@ -0,0 +1,42 @@
+import model from 'tango-api-schema';
+
+
+export async function find( query={}, field={} ) {
+  return model.planoProductModel.find( query, field );
+}
+
+
+export async function findOne( query={}, field={} ) {
+  return model.planoProductModel.findOne( query, field );
+}
+
+
+export async function insertMany( data ) {
+  return model.planoProductModel.insertMany( data );
+}
+
+export async function deleteMany( data ) {
+  return model.planoProductModel.deleteMany( data );
+}
+
+
+export async function aggregate( query ) {
+  return model.planoProductModel.aggregate( query );
+}
+
+
+export async function updateOne( query, record ) {
+  return model.planoProductModel.updateOne( query, { $set: record } );
+}
+
+export async function create( data ) {
+  return model.planoProductModel.create( data );
+}
+
+export async function upsertOne( query, record ) {
+  return model.planoProductModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}

package/src/service/planoProductDuplicate.service.js

@@ -0,0 +1,42 @@
+import model from 'tango-api-schema';
+
+
+export async function find( query={}, field={} ) {
+  return model.planoProductDetailDuplicateModel.find( query, field );
+}
+
+
+export async function findOne( query={}, field={} ) {
+  return model.planoProductDetailDuplicateModel.findOne( query, field );
+}
+
+
+export async function insertMany( data ) {
+  return model.planoProductDetailDuplicateModel.insertMany( data );
+}
+
+export async function deleteMany( data ) {
+  return model.planoProductDetailDuplicateModel.deleteMany( data );
+}
+
+
+export async function aggregate( query ) {
+  return model.planoProductDetailDuplicateModel.aggregate( query );
+}
+
+
+export async function updateOne( query, record ) {
+  return model.planoProductDetailDuplicateModel.updateOne( query, { $set: record } );
+}
+
+export async function create( data ) {
+  return model.planoProductDetailDuplicateModel.create( data );
+}
+
+export async function upsertOne( query, record ) {
+  return model.planoProductDetailDuplicateModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}

package/src/service/planoQrConversionRequest.service.js

@@ -0,0 +1,32 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.planoQrConversionRequest.find( query, field );
+}
+export async function findOne( query={}, field={} ) {
+  return model.planoQrConversionRequest.findOne( query, field );
+}
+
+export async function insertMany( data ) {
+  return model.planoQrConversionRequest.insertMany( data );
+}
+
+export async function aggregate( query ) {
+  return model.planoQrConversionRequest.aggregate( query );
+}
+
+export async function updateOne( query, record ) {
+  return model.planoQrConversionRequest.updateOne( query, { $set: record } );
+}
+
+export async function count( query ) {
+  return model.planoQrConversionRequest.countDocuments( query );
+}
+
+export async function create( data ) {
+  return model.planoQrConversionRequest.create( data );
+}
+
+export async function upsertOne( query, record ) {
+  return model.planoQrConversionRequest.updateOne( query, { $set: record }, { upsert: true } );
+}

package/src/service/planoRevision.service.js

@@ -0,0 +1,15 @@
+import model from 'tango-api-schema';
+
+const planoRevisionModel = model.planoRevisionModel;
+
+export const findOne = async ( query = {}, field = {} ) => {
+  return await planoRevisionModel.findOne( query, field );
+};
+
+export const find = async ( query = {}, field = {} ) => {
+  return await planoRevisionModel.find( query, field );
+};
+
+export const create = async ( data = {} ) => {
+  return await planoRevisionModel.create( data );
+};

package/src/service/planoStaticData.service.js

@@ -0,0 +1,11 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.planoStaticData.find( query, field );
+}
+export async function findOne( query={}, field={} ) {
+  return model.planoStaticData.findOne( query, field );
+}
+export async function updateOne( query={}, record={} ) {
+  return model.planoStaticData.updateOne( query, record, { upsert: true } );
+}

package/src/service/planoTask.service.js

@@ -0,0 +1,39 @@
+import model from 'tango-api-schema';
+
+export async function create( data ) {
+  return model.planoTaskCompliance.create( data );
+}
+
+export async function updateOne( query={}, record={} ) {
+  return model.planoTaskCompliance.updateOne( query, { $set: record }, { upsert: true } );
+}
+export async function updateMany( query={}, record={} ) {
+  return model.planoTaskCompliance.updateMany( query, { $set: record } );
+}
+export async function updateOnefilters( query={}, record={}, arrayfilter=[] ) {
+  return model.planoTaskCompliance.findOneAndUpdate( query, record, { arrayFilters: arrayfilter, returnDocument: 'after' } );
+}
+
+export async function findOne( query={}, field={} ) {
+  return model.planoTaskCompliance.findOne( query, field );
+}
+
+export async function find( query={}, field={} ) {
+  return model.planoTaskCompliance.find( query, field );
+}
+
+export async function count( data ) {
+  return model.planoTaskCompliance.countDocuments( data );
+}
+
+export async function aggregate( query ) {
+  return model.planoTaskCompliance.aggregate( query );
+}
+
+export async function deleteMany( query ) {
+  return model.planoTaskCompliance.deleteMany( query );
+}
+
+export async function findAndSort( query={}, field={}, sort={} ) {
+  return model.planoTaskCompliance.findOne( query, field ).sort( sort );
+}

package/src/service/planoVm.service.js

@@ -0,0 +1,49 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.planoVmModel.find( query, field );
+}
+
+export async function findOne( query={}, field={} ) {
+  return model.planoVmModel.findOne( query, field );
+}
+export async function findAndSort( query={}, field={}, sort={} ) {
+  return model.planoVmModel.find( query, field ).sort( sort ).collation( { locale: 'en_US', numericOrdering: true } );
+}
+
+export async function insertMany( data ) {
+  return model.planoVmModel.insertMany( data );
+}
+
+export async function deleteMany( data ) {
+  return model.planoVmModel.deleteMany( data );
+}
+
+
+export async function aggregate( query ) {
+  return model.planoVmModel.aggregate( query );
+}
+
+
+export async function deleteOne( query ) {
+  return model.planoVmModel.deleteOne( query );
+}
+
+export async function create( data ) {
+  return model.planoVmModel.create( data );
+}
+
+export async function upsertOne( query, record ) {
+  return model.planoVmModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+export async function updateOne( query, record ) {
+  return model.planoVmModel.updateOne( query, { $set: record }, { upsert: true } );
+}
+
+export async function count( query ) {
+  return model.planoVmModel.countDocuments( query );
+}