# v1.16.10

## Feature list

* CRUD API credentials
* [universal sessions] Sending files in Facebook
* Add cache headers for cdn response
* [universal sessions] "Entity type 12" (universal session system user)
* [universal sessions] Sending system eventId:2 to facebook and twilio users
* self session issues

## Services to deploy

* admin service
* main worker // progress
* core service // progress
* rake user app module // progress
* user app worker // progress

## DB

### Collection system config

db.getCollection("systemConfigs").update(
    { nodeEnv: 'test' },
    {
        $set: {
            "templates.workspaceRegistration.body.workspaceName": "{{workspace.name}}"
        }
    })

### Collection workspaceSystemUsers

const users = db.systemUsers.aggregate([
  {
      $match: { isRegistered: false/true }
  },
  {
      $lookup: {
          from: 'sessions',
          as: 'sessions',
          localField: 'entityId',
          foreignField: 'entities.entityId',
      }
  },
  {
      $match: {
          sessions: { $gt: { $size: 0 } }
      }
  },
  {
      $project: { systemUserId: 1 }
  }
]).toArray();


users.forEach((one) => {
    console.log('one.systemUserId', one.systemUserId);
    db.workspaceSystemUsers.updateMany({ systemUserId: one.systemUserId }, {
        $set: { entityTypeId: 12/4 }
    });
});

db.workspaceSystemUsers.createIndex( // done
    {
        "status": 1,
        "referenceValues.entity.firstName": 1,
        "referenceValues.entity.lastName": 1
    },
    {
        name: "SortIndex_status_referenceValues.entity.firstName_referenceValues.entity.lastName",
        collation: { locale: 'en', strength: 2 }
    }
);


db.workspaceSystemUsers.createIndex( // done
    {
        "referenceValues.entity.firstName": 1,
        "referenceValues.entity.lastName": 1
    },
    {
        name: "SortIndex_referenceValues.entity.firstName_referenceValues.entity.lastName",
        collation: { locale: 'en', strength: 2 }
    }
)

db.workspaceSystemUsers.createIndex( // done
    {
        
        "referenceValues.entity.lastName": 1,
        "referenceValues.entity.firstName": 1,
    },
    {
        name: "SortIndex_referenceValues.entity.lastName_referenceValues.entity.firstName",
        collation: { locale: 'en', strength: 2 }
    }
);
db.workspaceSystemUsers.updateMany({ status: { $exists: false } }, { $set: { status: 0 } }) // done

### Collection entityTypes // done

| entityTypeId | priority | isRoleEligible |
| ------------ | -------- | -------------- |
| 0 | 4 | false |
| 4 | 1 | true |
| 11 | 3 | true |
| 12 | 2 | true |

db.entityTypes.insert({  // done
    entityTypeId: 12,
    priority: 2,
    isRoleEligible: true,
    name: 'Universal User'
});

const updates = [  // done
    { entityTypeId: 0, priority: 4, isRoleEligible: false },
    { entityTypeId: 4, priority: 1, isRoleEligible: true },
    { entityTypeId: 11, priority: 3, isRoleEligible: true },
    { entityTypeId: 12, priority: 2, isRoleEligible: true },
];

updates.forEach((one) => {  // done
    db.entityTypes.updateOne({ entityTypeId: one.entityTypeId }, {
        $set: { ...one },
    });
});

### Collection roles // done

db.getCollection("roles").update(
    { roleId: 7 },
    { $push: { "systemFunctionIds": { "id": 591, "availablePermissionTypeIds": [ 2, 3 ]  } } }
)
db.roles.update(
    { 
        parentRoleId: { $exists: false },
        'scope.typeId': 'system',
    },
    { $set: { defaultEntityTypeId: 4 } }
);
db.roles.updateMany({ parentRoleId: { $exists: false } }, { $set: {defaultEntityTypeId:4} })
const prototypes = [
    // {label: 'organization', roleId: 1, name: "Organization API User", model: db.organizations, getId: doc => doc.organizationId },
    {label: 'project', roleId: 4, name: "Project API User", model: db.projects, getId: doc => doc.projectId },
    {label: 'workspace', roleId: 8, name: "Workspace API User", model: db.workspaces, getId: doc => doc.workspaceId }
];
for (const proto of prototypes){
    const roleId = proto.roleId;
    const [role] = db.roles.find({ roleId }).toArray();
    const pack = {
        "systemApplicationId": 1,
        "name": proto.name,
        "description": "",
        "systemFunctionIds": role.systemFunctionIds,
        "scope": role.scope,
        "createdAt": new Date(),
        "updatedAt": new Date(),
        "assignments": role.assignments,
        "defaultEntityTypeId": 11
    };
    
    const { count } = db.identitycounters.findOneAndUpdate({ model: 'roles' }, { $inc: { count: 1 } }, { returnNewDocument: true });
    pack.roleId = count;
    db.roles.insert(pack);
    
    const parentRoleId = count;
    const elements = proto.model.find({ }).projection({ "workspaceId": 1, "organizationId": 1, "projectId":1, "_id": 0 }).toArray();
    
    for (const [i, doc] of elements.entries()){
        const id = +proto.getId(doc).toString();
        console.log(`[${i}:${elements.length}] Insert new child role for ${proto.label} ${id}`);
        
        const duplicate = db.roles.findOne({
            'assignments.ids': [id],
            'assignments.type': proto.label,
            "parentRoleId": parentRoleId
        });
        if (duplicate) continue;
        
        const pack = {
            "systemApplicationId": 1,
            "name": proto.name,
            "description": "",
            "systemFunctionIds": [],
            "scope": { type: proto.label },
            "createdAt": new Date(),
            "updatedAt": new Date(),
            "assignments": {"ids": [id], "type": proto.label },
            parentRoleId
        };
        
        
        const { count } = db.identitycounters.findOneAndUpdate({ model: 'roles' }, { $inc: { count: 1 } }, { returnNewDocument: true });
        pack.roleId = count;
        db.roles.insert(pack);
        
    }
}

### Collection platforms // done

db.platforms.findOneAndUpdate(
    {
        "platformId": 3
    },
    { 
        $set: {
            "limitations.fileTransfer": 
                [
                    {
                        "type":"default",
                        "maxSize": 26214400,
                        "prohibitedFileExtensions": ["js", "exe", "zip", "rar"],
                        "allowedFileExtensions": ["json", "txt", "pdf", "csv" ]
                    },
                    {
                        "type":"audio",
                        "maxSize": 26214400,
                        "prohibitedFileExtensions": [],
                        "allowedFileExtensions": []
                        
                    },
                    {
                        "type":"image",
                        "maxSize": 26214400,
                        "prohibitedFileExtensions": [],
                        "allowedFileExtensions": ["jpg", "png"]
                        
                    }
                ]
            
            
        }
    }
);

### Collection Sessions // done

const updateDoc = [
    {
        $set: {
            'referenceValues.entitiesCount': { $size: '$entities' }
        }
    }
]

db.sessions.updateMany({ isActive: true } , updateDoc)

### SystemEventId: 2 // done

const localization = db.localizations.insertOne({
    "languages": [
        {
            "code": "en",
            "text": "{{firstName}} {{lastName}} just joined the {{channelName}} channel"
        }
    ],
    "systemApplicationIds": []
})

db.events.update({systemEventId:2}, {
    $set: {
        "localizations": {
            "defaultLocalizationId": localization.insertedId.toString(),
            "platforms": []
        }
    }
})