func Create()

in cfn-resources/database-user/cmd/resource/resource.go [19:140]
96 lines of code
14 McCabe index (conditional complexity)

func Create(req handler.Request, prevModel *Model, currentModel *Model) (handler.ProgressEvent, error) {
	setup()
	log.Debugf(" currentModel: %#+v, prevModel: %#+v", currentModel, prevModel)

	client, err := util.CreateMongoDBClient(*currentModel.ApiKeys.PublicKey, *currentModel.ApiKeys.PrivateKey)
	if err != nil {
		return handler.ProgressEvent{
			OperationStatus:  handler.Failed,
			Message:          err.Error(),
			HandlerErrorCode: cloudformation.HandlerErrorCodeInvalidRequest}, nil
	}

	var roles []mongodbatlas.Role
	for i, _ := range currentModel.Roles {
		r := currentModel.Roles[i]
		role := mongodbatlas.Role{}
		if r.CollectionName != nil {
			role.CollectionName = *r.CollectionName
		}

		if r.DatabaseName != nil {
			role.DatabaseName = *r.DatabaseName
		}

		if r.RoleName != nil {
			role.RoleName = *r.RoleName
		}

		roles = append(roles, role)
	}
	log.Debugf("roles: %#+v", roles)

	var labels []mongodbatlas.Label
	for i, _ := range currentModel.Labels {
		l := currentModel.Labels[i]
		label := mongodbatlas.Label{
			Key:   *l.Key,
			Value: *l.Value,
		}
		labels = append(labels, label)
	}
	log.Debugf("labels: %#+v", labels)

	var scopes []mongodbatlas.Scope
	for i, _ := range currentModel.Scopes {
		s := currentModel.Scopes[i]
		scope := mongodbatlas.Scope{
			Name: *s.Name,
			Type: *s.Type,
		}
		scopes = append(scopes, scope)
	}
	log.Debugf("scopes: %#+v", scopes)

	groupID := *currentModel.ProjectId
	log.Debugf("groupID: %#+v", groupID)

	none := "NONE"
	if currentModel.LdapAuthType == nil {
		currentModel.LdapAuthType = &none
	}

	if currentModel.AWSIAMType == nil {
		currentModel.AWSIAMType = &none
	}

	if currentModel.Password == nil {
		if (currentModel.LdapAuthType == &none) && (currentModel.AWSIAMType == &none) {
			err := fmt.Errorf("Password cannot be empty if not LDAP or IAM: %v", currentModel)
			return handler.ProgressEvent{
				OperationStatus:  handler.Failed,
				Message:          err.Error(),
				HandlerErrorCode: cloudformation.HandlerErrorCodeInvalidRequest}, nil
		}
		s := ""
		currentModel.Password = &s
	}

	user := &mongodbatlas.DatabaseUser{
		Roles:        roles,
		GroupID:      groupID,
		Username:     *currentModel.Username,
		Password:     *currentModel.Password,
		DatabaseName: *currentModel.DatabaseName,
		Labels:       labels,
		Scopes:       scopes,
		LDAPAuthType: *currentModel.LdapAuthType,
		AWSIAMType:   *currentModel.AWSIAMType,
	}

	/*
		projectResID := &util.ResourceIdentifier{
			ResourceType: "Project",
			ResourceID:   groupID,
		}
		resourceID := util.NewResourceIdentifier("DBUser", user.Username, projectResID)

		cfnid := resourceID.String()
		currentModel.UserCFNIdentifier = &cfnid
	*/
	cfnid := fmt.Sprintf("%s-%s", user.Username, groupID)
	currentModel.UserCFNIdentifier = &cfnid
	log.Debugf("Created UserCFNIdentifier: %s", cfnid)

	log.Debugf("Arguments: Project ID: %s, Request %#+v", groupID, user)

	newUser, res, err := client.DatabaseUsers.Create(context.Background(), groupID, user)
	if err != nil {
		log.Infof("Error creating new db user: res:%+v, err:%+v", res, err)
		return handler.ProgressEvent{
			Message:          err.Error(),
			OperationStatus:  handler.Failed,
			HandlerErrorCode: cloudformation.HandlerErrorCodeInvalidRequest}, nil
	}
	log.Debugf("newUser: %s", newUser)

	return handler.ProgressEvent{
		OperationStatus: handler.Success,
		Message:         "Create Complete",
		ResourceModel:   currentModel,
	}, nil
}