Google is committed to advancing racial equity for Black communities. See how.
ترجمت واجهة Cloud Translation API‏ هذه الصفحة.
Switch to English

استيراد مستخدمين

توفر حزمة auth.importUsers() Admin SDK واجهة برمجة تطبيقات auth.importUsers() لاستيراد المستخدمين بشكل مجمع إلى مصادقة Firebase بامتيازات عالية. على الرغم من توفر هذه الميزة أيضًا في Firebase CLI ، تتيح لك Admin SDK تحميل المستخدمين الحاليين من نظام مصادقة خارجي أو مشروع Firebase برمجيًا دون الحاجة إلى إنشاء ملفات CSV أو JSON الوسيطة.

تقدم واجهة برمجة تطبيقات استيراد المستخدم المزايا التالية:

  • القدرة على ترحيل المستخدمين من نظام مصادقة خارجي باستخدام خوارزمية تجزئة كلمة مرور مختلفة.
  • القدرة على ترحيل المستخدمين من مشروع Firebase آخر.
  • تحسين عمليات الاستيراد بالجملة بسرعة وكفاءة. هذه العملية عمليات المستخدمين دون التحقق من وجود uid ، email ، phoneNumber أو غيرها من الازدواجية المعرف.
  • القدرة على ترحيل مستخدمي OAuth الحاليين أو إنشاء مواقع جديدة (Google ، Facebook ، إلخ).
  • القدرة على استيراد المستخدمين ذوي المطالبات المخصصة بشكل مجمّع مباشرةً.

الاستخدام

يمكن استيراد ما يصل إلى 1000 مستخدم في مكالمة API واحدة. لاحظ أن هذه العملية تم تحسينها للسرعة ولا تتحقق من uid email و phoneNumber وغيرها من تكرار المعرف الفريد. استيراد المستخدم الذي يصطدم مع القائمة uid سوف تحل محل مستخدم موجود. سيؤدي استيراد مستخدم مع أي حقل آخر مكرر (مثل email ) إلى مستخدم إضافي بنفس القيمة. وبالتالي ، عند استخدام واجهة برمجة التطبيقات هذه ، يجب عليك التأكد من عدم تكرار أي حقول فريدة.

Node.js

 // Up to 1000 users can be imported at once.
let userImportRecords = [
  {
    uid: 'uid1',
    email: 'user1@example.com',
    passwordHash: Buffer.from('passwordHash1'),
    passwordSalt: Buffer.from('salt1')
  },
  {
    uid: 'uid2',
    email: 'user2@example.com',
    passwordHash: Buffer.from('passwordHash2'),
    passwordSalt: Buffer.from('salt2')
  },
  //...
];
 

جافا

 // Up to 1000 users can be imported at once.
List<ImportUserRecord> users = new ArrayList<>();
users.add(ImportUserRecord.builder()
    .setUid("uid1")
    .setEmail("user1@example.com")
    .setPasswordHash("passwordHash1".getBytes())
    .setPasswordSalt("salt1".getBytes())
    .build());
users.add(ImportUserRecord.builder()
    .setUid("uid2")
    .setEmail("user2@example.com")
    .setPasswordHash("passwordHash2".getBytes())
    .setPasswordSalt("salt2".getBytes())
    .build());
 

بيثون

 # Up to 1000 users can be imported at once.
users = [
    auth.ImportUserRecord(
        uid='uid1',
        email='user1@example.com',
        password_hash=b'password_hash_1',
        password_salt=b'salt1'
    ),
    auth.ImportUserRecord(
        uid='uid2',
        email='user2@example.com',
        password_hash=b'password_hash_2',
        password_salt=b'salt2'
    ),
]
 

اذهب

 // Up to 1000 users can be imported at once.
var users []*auth.UserToImport
users = append(users, (&auth.UserToImport{}).
	UID("uid1").
	Email("user1@example.com").
	PasswordHash([]byte("passwordHash1")).
	PasswordSalt([]byte("salt1")))
users = append(users, (&auth.UserToImport{}).
	UID("uid2").
	Email("user2@example.com").
	PasswordHash([]byte("passwordHash2")).
	PasswordSalt([]byte("salt2")))
 

ج #

 //  Up to 1000 users can be imported at once.
var users = new List<ImportUserRecordArgs>()
{
    new ImportUserRecordArgs()
    {
        Uid = "uid1",
        Email = "user1@example.com",
        PasswordHash = Encoding.ASCII.GetBytes("passwordHash1"),
        PasswordSalt = Encoding.ASCII.GetBytes("salt1"),
    },
    new ImportUserRecordArgs()
    {
        Uid = "uid2",
        Email = "user2@example.com",
        PasswordHash = Encoding.ASCII.GetBytes("passwordHash2"),
        PasswordSalt = Encoding.ASCII.GetBytes("salt2"),
    },
};
 

في هذا المثال ، تم تحديد خيارات التجزئة لمساعدة Firebase بشكل آمن في مصادقة هؤلاء المستخدمين في المرة التالية التي يحاولون فيها تسجيل الدخول باستخدام مصادقة Firebase. عند تسجيل الدخول بنجاح ، يعيد Firebase تجزئة كلمة مرور المستخدم باستخدام خوارزمية تجزئة Firebase الداخلية. تعرف على المزيد حول الحقول المطلوبة لكل خوارزمية أدناه.

تحاول مصادقة Firebase تحميل القائمة الكاملة للمستخدمين المقدمين حتى عند حدوث خطأ خاص بالمستخدم. ترجع العملية نتيجة مع ملخص عمليات الاستيراد الناجحة والفاشلة. يتم إرجاع تفاصيل الخطأ لكل استيراد مستخدم فاشل.

Node.js

 admin.auth().importUsers(userImportRecords, {
    hash: {
      algorithm: 'HMAC_SHA256',
      key: Buffer.from('secretKey')
    }
  })
  .then(function(userImportResult) {
    // The number of successful imports is determined via: userImportResult.successCount.
    // The number of failed imports is determined via: userImportResult.failureCount.
    // To get the error details.
    userImportResult.errors.forEach(function(indexedError) {
      // The corresponding user that failed to upload.
      console.log('Error ' + indexedError.index, ' failed to import: ' ,indexedError.error);
    });
  })
  .catch(function(error) {
    // Some unrecoverable error occurred that prevented the operation from running.
  });
 

جافا

 UserImportOptions options = UserImportOptions.withHash(
    HmacSha256.builder()
        .setKey("secretKey".getBytes())
        .build());
try {
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  System.out.println("Successfully imported " + result.getSuccessCount() + " users");
  System.out.println("Failed to import " + result.getFailureCount() + " users");
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user at index: " + indexedError.getIndex()
        + " due to error: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  // Some unrecoverable error occurred that prevented the operation from running.
}
 

بيثون

 hash_alg = auth.UserImportHash.hmac_sha256(key=b'secret_key')
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    print('Successfully imported {0} users. Failed to import {1} users.'.format(
        result.success_count, result.failure_count))
    for err in result.errors:
        print('Failed to import {0} due to {1}'.format(users[err.index].uid, err.reason))
except exceptions.FirebaseError:
    # Some unrecoverable error occurred that prevented the operation from running.
    pass
 

اذهب

 client, err := app.Auth(ctx)
if err != nil {
	log.Fatalln("Error initializing Auth client", err)
}

h := hash.HMACSHA256{
	Key: []byte("secretKey"),
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Unrecoverable error prevented the operation from running", err)
}

log.Printf("Successfully imported %d users\n", result.SuccessCount)
log.Printf("Failed to import %d users\n", result.FailureCount)
for _, e := range result.Errors {
	log.Printf("Failed to import user at index: %d due to error: %s\n", e.Index, e.Reason)
}
 

ج #

 var options = new UserImportOptions()
{
    Hash = new HmacSha256()
    {
        Key = Encoding.ASCII.GetBytes("secretKey"),
    },
};

try
{
    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    Console.WriteLine($"Successfully imported {result.SuccessCount} users");
    Console.WriteLine($"Failed to import {result.FailureCount} users");
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user at index: {indexedError.Index}"
            + $" due to error: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException)
{
    // Some unrecoverable error occurred that prevented the operation from running.
}

 

إذا لم تكن هناك حاجة إلى تجزئة كلمة المرور (رقم الهاتف ، مستخدم الرمز المميز المخصص ، مستخدم OAuth وما إلى ذلك) ، فلا تقدم خيارات التجزئة.

استيراد المستخدمين باستخدام كلمات مرور HMAC المجزأة

تتضمن خوارزميات التجزئة HMAC: HMAC_MD5 و HMAC_SHA1 و HMAC_SHA256 و HMAC_SHA512 . بالنسبة إلى خوارزميات التجزئة هذه ، يجب عليك توفير مفتاح علامة التجزئة.

Node.js

 admin.auth().importUsers([{
  uid: 'some-uid',
  email: 'user@example.com',
  // Must be provided in a byte buffer.
  passwordHash: Buffer.from('password-hash'),
  // Must be provided in a byte buffer.
  passwordSalt: Buffer.from('salt')
}], {
  hash: {
    algorithm: 'HMAC_SHA256',
    // Must be provided in a byte buffer.
    key: Buffer.from('secret')
  }
})
  .then(function(results) {
    results.errors.forEach(function(indexedError) {
     console.log('Error importing user ' + indexedError.index);
    });
  })
  .catch(function(error) {
    console.log('Error importing users:', error);
  });
 

جافا

 try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("user@example.com")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(
      HmacSha256.builder()
          .setKey("secret".getBytes())
          .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}
 

بيثون

 users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='user@example.com',
        password_hash=b'password_hash',
        password_salt=b'salt'
    ),
]

hash_alg = auth.UserImportHash.hmac_sha256(key=b'secret')
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)
 

اذهب

 users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("user@example.com").
		PasswordHash([]byte("password-hash")).
		PasswordSalt([]byte("salt")),
}
h := hash.HMACSHA256{
	Key: []byte("secret"),
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}
 

ج #

 try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "user@example.com",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        Hash = new HmacSha256()
        {
            Key = Encoding.ASCII.GetBytes("secret"),
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

 

قم باستيراد المستخدمين باستخدام MD5 و SHA و PBKDF كلمات المرور المجزأة

تتضمن خوارزميات التجزئة MD5 و SHA و PBKDF: MD5 و SHA1 و SHA256 و SHA512 و PBKDF_SHA1 و PBKDF2_SHA256 . بالنسبة إلى خوارزميات التجزئة هذه ، يجب عليك توفير عدد الجولات (بين 0 و 8192 لـ MD5 ، وبين 1 و 8192 لـ SHA1 و SHA256 و SHA512 ، وبين 0 و 120000 لـ PBKDF_SHA1 و PBKDF2_SHA256 ) المستخدمة PBKDF2_SHA256 كلمة المرور.

Node.js

 admin.auth().importUsers([{
  uid: 'some-uid',
  email: 'user@example.com',
  // Must be provided in a byte buffer.
  passwordHash: Buffer.from('password-hash'),
  // Must be provided in a byte buffer.
  passwordSalt: Buffer.from('salt')
}], {
  hash: {
    algorithm: 'PBKDF2_SHA256',
    rounds: 100000
  }
})
  .then(function(results) {
   results.errors.forEach(function(indexedError) {
      console.log('Error importing user ' + indexedError.index);
    });
  })
  .catch(function(error) {
    console.log('Error importing users:', error);
  });
 

جافا

 try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("user@example.com")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(
      Pbkdf2Sha256.builder()
          .setRounds(100000)
          .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}
 

بيثون

 users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='user@example.com',
        password_hash=b'password_hash',
        password_salt=b'salt'
    ),
]

hash_alg = auth.UserImportHash.pbkdf2_sha256(rounds=100000)
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)
 

اذهب

 users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("user@example.com").
		PasswordHash([]byte("password-hash")).
		PasswordSalt([]byte("salt")),
}
h := hash.PBKDF2SHA256{
	Rounds: 100000,
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}
 

ج #

 try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "user@example.com",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        Hash = new Pbkdf2Sha256()
        {
            Rounds = 100000,
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

 

استيراد المستخدمين باستخدام كلمات مرور تجزئة SCRYPT القياسية

تدعم مصادقة Firebase خوارزمية SCRYPT القياسية بالإضافة إلى إصدار معدل داخلي . بالنسبة لخوارزمية SCRYPT القياسية ، يلزم استخدام معلمات التجزئة التالية:

  • memoryCost : تكلفة وحدة المعالجة المركزية / الذاكرة لخوارزمية التجزئة.
  • parallelization : موازاة خوارزمية التجزئة.
  • blockSize : حجم الكتلة (عادة 8) لخوارزمية التجزئة.
  • derivedKeyLength : طول المفتاح المشتق من خوارزمية التجزئة

Node.js

 admin.auth().importUsers([{
  uid: 'some-uid',
  email: 'user@example.com',
  // Must be provided in a byte buffer.
  passwordHash: Buffer.from('password-hash'),
  // Must be provided in a byte buffer.
  passwordSalt: Buffer.from('salt')
}], {
  hash: {
    algorithm: 'STANDARD_SCRYPT',
    memoryCost: 1024,
    parallelization: 16,
    blockSize: 8,
    derivedKeyLength: 64
  }
})
  .then(function(results) {
    results.errors.forEach(function(indexedError) {
     console.log('Error importing user ' + indexedError.index);
    });
  })
  .catch(function(error) {
    console.log('Error importing users:', error);
  });
 

جافا

 try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("user@example.com")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(
      StandardScrypt.builder()
          .setMemoryCost(1024)
          .setParallelization(16)
          .setBlockSize(8)
          .setDerivedKeyLength(64)
          .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}
 

بيثون

 users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='user@example.com',
        password_hash=b'password_hash',
        password_salt=b'salt'
    ),
]

hash_alg = auth.UserImportHash.standard_scrypt(
    memory_cost=1024, parallelization=16, block_size=8, derived_key_length=64)
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)
 

اذهب

 users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("user@example.com").
		PasswordHash([]byte("password-hash")).
		PasswordSalt([]byte("salt")),
}
h := hash.StandardScrypt{
	MemoryCost:       1024,
	Parallelization:  16,
	BlockSize:        8,
	DerivedKeyLength: 64,
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}
 

ج #

 try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "user@example.com",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        Hash = new StandardScrypt()
        {
            MemoryCost = 1024,
            Parallelization = 16,
            BlockSize = 8,
            DerivedKeyLength = 64,
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

 

استيراد المستخدمين الذين لديهم كلمات مرور مجزأة BCRYPT

بالنسبة لكلمات المرور المجزأة لـ BCRYPT ، لا يلزم وجود معلمات تجزئة إضافية أو أملاح كلمة المرور لكل مستخدم.

Node.js

 admin.auth().importUsers([{
  uid: 'some-uid',
  email: 'user@example.com',
  // Must be provided in a byte buffer.
  passwordHash: Buffer.from('password-hash')
}], {
  hash: {
    algorithm: 'BCRYPT'
  }
})
  .then(function(results) {
    results.errors.forEach(function(indexedError) {
      console.log('Error importing user ' + indexedError.index);
    });
  })
  .catch(function(error) {
    console.log('Error importing users:', error);
  });
 

جافا

 try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("user@example.com")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(Bcrypt.getInstance());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}
 

بيثون

 users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='user@example.com',
        password_hash=b'password_hash',
        password_salt=b'salt'
    ),
]

hash_alg = auth.UserImportHash.bcrypt()
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)
 

اذهب

 users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("user@example.com").
		PasswordHash([]byte("password-hash")).
		PasswordSalt([]byte("salt")),
}
h := hash.Bcrypt{}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}
 

ج #

 try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "user@example.com",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        Hash = new Bcrypt(),
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

 

استيراد المستخدمين باستخدام كلمات مرور مجزأة في Firebase SCRYPT

يعد استيراد كلمات المرور التي تم تجزئتها باستخدام إصدار Firebase المعدل من خوارزمية التجزئة SCRYPT مفيدًا لترحيل المستخدمين من مشروع آخر موجود في Firebase. للقيام بذلك ، يجب تحديد المعلمات الداخلية للمشروع الأصلي.

ينشئ Firebase معلمات تجزئة كلمة مرور فريدة لكل مشروع Firebase. للوصول إلى هذه المعلمات ، انتقل إلى علامة التبويب " المستخدمون" في وحدة تحكم Firebase وحدد معلمات تجزئة كلمة المرور من القائمة المنسدلة في الزاوية العلوية اليمنى من قائمة المستخدمين.

تتضمن المعلمات اللازمة لإنشاء خيارات التجزئة لهذه الخوارزمية:

  • key : key التوقيع الذي يتم توفيره عادةً في ترميز base64.
  • saltSeparator : يتم توفير فاصل الملح عادة في ترميز base64 (اختياري).
  • rounds : عدد الجولات المستخدمة لتجزئة كلمات المرور.
  • memoryCost : تكلفة الذاكرة المطلوبة لهذه الخوارزمية.

Node.js

 admin.auth().importUsers([{
  uid: 'some-uid',
  email: 'user@example.com',
  // Must be provided in a byte buffer.
  passwordHash: Buffer.from('base64-password-hash', 'base64'),
  // Must be provided in a byte buffer.
  passwordSalt: Buffer.from('base64-salt', 'base64'),
}], {
  hash: {
    algorithm: 'SCRYPT',
    // All the parameters below can be obtained from the Firebase Console's users section.
    // Must be provided in a byte buffer.
    key: Buffer.from('base64-secret', 'base64'),
    saltSeparator: Buffer.from('base64SaltSeparator', 'base64'),
    rounds: 8,
    memoryCost: 14
  }
})
  .then(function(results) {
    results.errors.forEach(function(indexedError) {
      console.log('Error importing user ' + indexedError.index);
    });
  })
  .catch(function(error) {
    console.log('Error importing users:', error);
  });
 

جافا

 try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setEmail("user@example.com")
      .setPasswordHash("password-hash".getBytes())
      .setPasswordSalt("salt".getBytes())
      .build());
  UserImportOptions options = UserImportOptions.withHash(
      Scrypt.builder()
          // All the parameters below can be obtained from the Firebase Console's "Users"
          // section. Base64 encoded parameters must be decoded into raw bytes.
          .setKey(BaseEncoding.base64().decode("base64-secret"))
          .setSaltSeparator(BaseEncoding.base64().decode("base64-salt-separator"))
          .setRounds(8)
          .setMemoryCost(14)
          .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users, options);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}
 

بيثون

 users = [
    auth.ImportUserRecord(
        uid='some-uid',
        email='user@example.com',
        password_hash=b'password_hash',
        password_salt=b'salt'
    ),
]

# All the parameters below can be obtained from the Firebase Console's "Users"
# section. Base64 encoded parameters must be decoded into raw bytes.
hash_alg = auth.UserImportHash.scrypt(
    key=base64.b64decode('base64_secret'),
    salt_separator=base64.b64decode('base64_salt_separator'),
    rounds=8,
    memory_cost=14
)
try:
    result = auth.import_users(users, hash_alg=hash_alg)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)
 

اذهب

 users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		Email("user@example.com").
		PasswordHash([]byte("password-hash")).
		PasswordSalt([]byte("salt")),
}
b64decode := func(s string) []byte {
	b, err := base64.StdEncoding.DecodeString(s)
	if err != nil {
		log.Fatalln("Failed to decode string", err)
	}
	return b
}

// All the parameters below can be obtained from the Firebase Console's "Users"
// section. Base64 encoded parameters must be decoded into raw bytes.
h := hash.Scrypt{
	Key:           b64decode("base64-secret"),
	SaltSeparator: b64decode("base64-salt-separator"),
	Rounds:        8,
	MemoryCost:    14,
}
result, err := client.ImportUsers(ctx, users, auth.WithHash(h))
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}
 

ج #

 try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            Email = "user@example.com",
            PasswordHash = Encoding.ASCII.GetBytes("password-hash"),
            PasswordSalt = Encoding.ASCII.GetBytes("salt"),
        },
    };

    var options = new UserImportOptions()
    {
        // All the parameters below can be obtained from the Firebase Console's "Users"
        // section. Base64 encoded parameters must be decoded into raw bytes.
        Hash = new Scrypt()
        {
            Key = Encoding.ASCII.GetBytes("base64-secret"),
            SaltSeparator = Encoding.ASCII.GetBytes("base64-salt-separator"),
            Rounds = 8,
            MemoryCost = 14,
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users, options);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}

 

استيراد مستخدمين بدون كلمات مرور

يمكنك استيراد مستخدمين بدون كلمات مرور. يمكن استيراد المستخدمين الذين ليس لديهم كلمات مرور بالاشتراك مع المستخدمين الذين لديهم موفري OAuth والمطالبات المخصصة وأرقام الهواتف وما إلى ذلك.

Node.js

 admin.auth().importUsers([{
  uid: 'some-uid',
  displayName: 'John Doe',
  email: 'johndoe@gmail.com',
  photoURL: 'http://www.example.com/12345678/photo.png',
  emailVerified: true,
  phoneNumber: '+11234567890',
  // Set this user as admin.
  customClaims: {admin: true},
  // User with Google provider.
  providerData: [{
    uid: 'google-uid',
    email: 'johndoe@gmail.com',
    displayName: 'John Doe',
    photoURL: 'http://www.example.com/12345678/photo.png',
    providerId: 'google.com'
  }]
}])
  .then(function(results) {
    results.errors.forEach(function(indexedError) {
     console.log('Error importing user ' + indexedError.index);
    });
  })
  .catch(function(error) {
    console.log('Error importing users:', error);
  });
 

جافا

 try {
  List<ImportUserRecord> users = Collections.singletonList(ImportUserRecord.builder()
      .setUid("some-uid")
      .setDisplayName("John Doe")
      .setEmail("johndoe@gmail.com")
      .setPhotoUrl("http://www.example.com/12345678/photo.png")
      .setEmailVerified(true)
      .setPhoneNumber("+11234567890")
      .putCustomClaim("admin", true) // set this user as admin
      .addUserProvider(UserProvider.builder() // user with Google provider
          .setUid("google-uid")
          .setEmail("johndoe@gmail.com")
          .setDisplayName("John Doe")
          .setPhotoUrl("http://www.example.com/12345678/photo.png")
          .setProviderId("google.com")
          .build())
      .build());
  UserImportResult result = FirebaseAuth.getInstance().importUsers(users);
  for (ErrorInfo indexedError : result.getErrors()) {
    System.out.println("Failed to import user: " + indexedError.getReason());
  }
} catch (FirebaseAuthException e) {
  System.out.println("Error importing users: " + e.getMessage());
}
 

بيثون

 users = [
    auth.ImportUserRecord(
        uid='some-uid',
        display_name='John Doe',
        email='johndoe@gmail.com',
        photo_url='http://www.example.com/12345678/photo.png',
        email_verified=True,
        phone_number='+11234567890',
        custom_claims={'admin': True}, # set this user as admin
        provider_data=[ # user with Google provider
            auth.UserProvider(
                uid='google-uid',
                email='johndoe@gmail.com',
                display_name='John Doe',
                photo_url='http://www.example.com/12345678/photo.png',
                provider_id='google.com'
            )
        ],
    ),
]
try:
    result = auth.import_users(users)
    for err in result.errors:
        print('Failed to import user:', err.reason)
except exceptions.FirebaseError as error:
    print('Error importing users:', error)
 

اذهب

 users := []*auth.UserToImport{
	(&auth.UserToImport{}).
		UID("some-uid").
		DisplayName("John Doe").
		Email("johndoe@gmail.com").
		PhotoURL("http://www.example.com/12345678/photo.png").
		EmailVerified(true).
		PhoneNumber("+11234567890").
		CustomClaims(map[string]interface{}{"admin": true}). // set this user as admin
		ProviderData([]*auth.UserProvider{                   // user with Google provider
			{
				UID:         "google-uid",
				Email:       "johndoe@gmail.com",
				DisplayName: "John Doe",
				PhotoURL:    "http://www.example.com/12345678/photo.png",
				ProviderID:  "google.com",
			},
		}),
}
result, err := client.ImportUsers(ctx, users)
if err != nil {
	log.Fatalln("Error importing users", err)
}
for _, e := range result.Errors {
	log.Println("Failed to import user", e.Reason)
}
 

ج #

 try
{
    var users = new List<ImportUserRecordArgs>()
    {
        new ImportUserRecordArgs()
        {
            Uid = "some-uid",
            DisplayName = "John Doe",
            Email = "johndoe@gmail.com",
            PhotoUrl = "http://www.example.com/12345678/photo.png",
            EmailVerified = true,
            PhoneNumber = "+11234567890",
            CustomClaims = new Dictionary<string, object>()
            {
                { "admin", true }, // set this user as admin
            },
            UserProviders = new List<UserProvider>
            {
                new UserProvider() // user with Google provider
                {
                    Uid = "google-uid",
                    Email = "johndoe@gmail.com",
                    DisplayName = "John Doe",
                    PhotoUrl = "http://www.example.com/12345678/photo.png",
                    ProviderId = "google.com",
                },
            },
        },
    };

    UserImportResult result = await FirebaseAuth.DefaultInstance.ImportUsersAsync(users);
    foreach (ErrorInfo indexedError in result.Errors)
    {
        Console.WriteLine($"Failed to import user: {indexedError.Reason}");
    }
}
catch (FirebaseAuthException e)
{
    Console.WriteLine($"Error importing users: {e.Message}");
}