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

package/src/service/planoVmDuplicate.service.js

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

package/src/service/planogram.service.js

@@ -28,6 +28,14 @@ export async function deleteOne( query ) {
   return model.planogramModel.deleteOne( query );
 }
 
+export async function upsertOne( query, record ) {
+  return model.planogramModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+
 export async function create( data ) {
   return model.planogramModel.create( data );
 }

package/src/service/planoproductCategory.service.js

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

package/src/service/processedTaskservice.js

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

package/src/service/processedchecklist.service.js

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

package/src/service/storeBuilder.service.js

@@ -8,6 +8,10 @@ export async function findOne( query={}, field={} ) {
   return model.storeLayoutModel.findOne( query, field ).sort( { floorNumber: -1 } );
 }
 
+export async function findOneAndUpdate( query={}, field={} ) {
+  return model.storeLayoutModel.findOneAndUpdate( query, field ).sort( { floorNumber: -1 } );
+}
+
 export async function insertMany( data ) {
   return model.storeLayoutModel.insertMany( data );
 }
@@ -31,3 +35,19 @@ export async function updateOne( query, record ) {
 export async function updateMany( query, record ) {
   return model.storeLayoutModel.updateMany( query, { $set: record } );
 }
+
+export async function create( data ) {
+  return model.storeLayoutModel.create( data );
+}
+
+export async function upsertOne( query, record ) {
+  return model.storeLayoutModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+
+export async function count( query ) {
+  return model.storeLayoutModel.countDocuments( query );
+}

package/src/service/storeBuilderDuplicate.service.js

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

package/src/service/storeFixture.service.js

@@ -0,0 +1,83 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={} ) {
+  return model.storeFixtureModel.find( query, field );
+}
+
+export async function findOne( query={}, field={} ) {
+  return model.storeFixtureModel.findOne( query, field );
+}
+
+export async function insertMany( data ) {
+  return model.storeFixtureModel.insertMany( data );
+}
+
+export async function aggregate( query ) {
+  return model.storeFixtureModel.aggregate( query );
+}
+
+export async function updateOne( query, record ) {
+  return model.storeFixtureModel.updateOne( query, { $set: record } );
+}
+
+export async function updateMany( query, record ) {
+  return model.storeFixtureModel.updateMany( query, { $set: record } );
+}
+
+export async function findOneAndUpdate( query={}, field={} ) {
+  return model.storeFixtureModel.findOneAndUpdate( query, field );
+}
+
+export async function findOneAndUpdate2( query={}, field={} ) {
+  return model.storeFixtureModel.findOneAndUpdate( query, field, { new: true } );
+}
+
+export async function create( data ) {
+  return model.storeFixtureModel.create( data );
+}
+
+export async function deleteOne( query ) {
+  return model.storeFixtureModel.deleteOne( query );
+}
+
+export async function deleteMany( query ) {
+  return model.storeFixtureModel.deleteMany( query );
+}
+
+export async function findAndSort( query={}, field={}, sortField={} ) {
+  return model.storeFixtureModel.find( query, field ).sort( sortField );
+}
+
+export async function upsertOne( query, record ) {
+  return model.storeFixtureModel.findOneAndUpdate(
+      query,
+      record,
+      { upsert: true, new: true },
+  );
+}
+
+export async function removeKeys( query, data ) {
+  return model.storeFixtureModel.updateOne( query, data );
+}
+
+export async function count( query ) {
+  return model.storeFixtureModel.countDocuments( query );
+}
+
+export async function updateOneArrayItem( query, record, filter ) {
+  return model.storeFixtureModel.updateOne( query, record, filter );
+}
+
+export async function bulkUpsert(dataList = [], matchKey = '_id') {
+  if (!Array.isArray(dataList) || dataList.length === 0) return [];
+
+  const operations = dataList.map(item => ({
+    updateOne: {
+      filter: { [matchKey]: item[matchKey] },
+      update: { $set: item },
+      upsert: true,
+    },
+  }));
+
+  return model.storeFixtureModel.bulkWrite(operations);
+}

package/src/service/storeFixtureDuplicate.service.js

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

package/src/service/task.service.js

@@ -0,0 +1,6 @@
+import model from 'tango-api-schema';
+
+export async function find( query = {}, field={} ) {
+  return await model.taskConfigModel.find( query, field );
+}
+

package/src/service/templateLog.service.js

@@ -0,0 +1,10 @@
+import model from 'tango-api-schema';
+
+export async function find( query={}, field={}, sort={} ) {
+  return model.templateLogSchema.find( query, field ).sort( sort );
+}
+
+export async function create( data = {} ) {
+  return model.templateLogSchema.create( data );
+}
+

package/src/service/user.service.js

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

package/src/service/vmType.service.js

@@ -0,0 +1,33 @@
+import model from 'tango-api-schema';
+
+export const findOne = async ( query ={}, field = {} ) => {
+  return model.vmTypeModel.findOne( query, field );
+};
+
+export const deleteOne = async ( query ={} ) => {
+  return model.vmTypeModel.deleteOne( query );
+};
+
+export const deleteMany = async ( query ={} ) => {
+  return model.vmTypeModel.deleteMany( query );
+};
+
+export const create = async ( data ) => {
+  return model.vmTypeModel.create( data );
+};
+
+export const find = async ( query ={}, field = {} ) => {
+  return model.vmTypeModel.find( query, field );
+};
+
+export const updateOne = async ( query ={}, record = {} ) => {
+  return model.vmTypeModel.updateOne( query, { $set: record } );
+};
+
+export const updateKeys = async ( query ={}, record = {} ) => {
+  return model.vmTypeModel.updateOne( query, record );
+};
+
+export const insertMany = async ( data ) => {
+  return model.vmTypeModel.insertMany( data );
+};